mcrl2-201210.1/3rd-party/README000664 001751 001751 00000002767 12042421220 016635 0ustar00jenkinsjenkins000000 000000 This directory contains four libraries that are used by the mCRL2 toolset. The four libraries are: aterm gl2ps svc tr Below these libraries have a compact additional explanation. aterm ----- The aterm library was made by de group SEN1 at CWI in Amsterdam. It contains routines to store and manipulate term structures. Most of the term sorts in the mCRL2 are directly mapped onto the terms. The terms are stored in a shared fashion, which if used properly can reduce the term footprint in memory substantially. Furthermore, the library contains its own term garbage mechanism, which requires to carefully protect and unprotect some terms. M.G.J. van den Brand, H.A. de Jong, P. Klint, P.A. Olivier. Efficient annotated terms Seriesr. Technical report. CWI. Software Engineering [SEN], Nr. R0003, 2000, ISSN: 1386-369X. See www.cwi.nl. gl2ps ----- This is a package that translates openGL commands into postscript. This is only used to make high definition pictures of the objects representing statespaces in ltsview. svc --- The system validation center (svc) format is a format to store labelled transition systems compactly with state and label information. It was written by Izak van Langevelde. The labels of the transitions are ATerms. I.A. van Langevelde. A compact file format for labeled transition systems. Technical report. CWI. Software Engineering [SEN], Nr. R 0102, 2001, ISSN: 1386-369X. See www.cwi.nl. tr -- This is a tile redering package that is used to render pictures in ltsview. mcrl2-201210.1/3rd-party/tr/include/tr/tr.h000664 001751 001751 00000007133 12042421220 021240 0ustar00jenkinsjenkins000000 000000 /* $Id: tr.h,v 1.5 1997/07/21 17:34:07 brianp Exp $ */ /* * $Log: tr.h,v $ * Revision 1.5 1997/07/21 17:34:07 brianp * added tile borders, incremented version to 1.1 * * Revision 1.4 1997/07/21 15:47:35 brianp * renamed all "near" and "far" variables * * Revision 1.3 1997/04/26 21:23:25 brianp * added trRasterPos3f function * * Revision 1.2 1997/04/19 23:26:10 brianp * many API changes * * Revision 1.1 1997/04/18 21:53:05 brianp * Initial revision * */ /* * Tiled Rendering library * Version 1.1 * Copyright (C) Brian Paul * * * This library allows one to render arbitrarily large images with OpenGL. * The basic idea is to break the image into tiles which are rendered one * at a time. The tiles are assembled together to form the final, large * image. Tiles and images can be of any size. * * Basic usage: * * 1. Allocate a tile rendering context: * TRcontext t = trNew(); * * 2. Specify the final image buffer and tile size: * GLubyte image[W][H][4] * trImageSize(t, W, H); * trImageBuffer(t, GL_RGBA, GL_UNSIGNED_BYTE, (GLubyte *) image); * * 3. Setup your projection: * trFrustum(t, left, right, bottom top, near, far); * or * trOrtho(t, left, right, bottom top, near, far); * or * trPerspective(t, fovy, aspect, near, far); * * 4. Render the tiles: * do { * trBeginTile(t); * DrawMyScene(); * } while (trEndTile(t)); * * You provide the DrawMyScene() function which calls glClear() and * draws all your stuff. * * 5. The image array is now complete. Display it, write it to a file, etc. * * 6. Delete the tile rendering context when finished: * trDelete(t); * */ #ifndef TR_H #define TR_H #ifdef __APPLE__ #include #else #include #endif #ifdef __cplusplus extern "C" { #endif #define TR_VERSION "1.1" #define TR_MAJOR_VERSION 1 #define TR_MINOR_VERSION 1 typedef struct _TRctx TRcontext; typedef enum { TR_TILE_WIDTH = 100, TR_TILE_HEIGHT, TR_TILE_BORDER, TR_IMAGE_WIDTH, TR_IMAGE_HEIGHT, TR_ROWS, TR_COLUMNS, TR_CURRENT_ROW, TR_CURRENT_COLUMN, TR_CURRENT_TILE_WIDTH, TR_CURRENT_TILE_HEIGHT, TR_ROW_ORDER, TR_TOP_TO_BOTTOM, TR_BOTTOM_TO_TOP } TRenum; extern TRcontext* trNew(void); extern void trDelete(TRcontext* tr); extern void trTileSize(TRcontext* tr, GLint width, GLint height, GLint border); extern void trTileBuffer(TRcontext* tr, GLenum format, GLenum type, GLvoid* image); extern void trImageSize(TRcontext* tr, GLint width, GLint height); extern void trImageBuffer(TRcontext* tr, GLenum format, GLenum type, GLvoid* image); extern void trRowOrder(TRcontext* tr, TRenum order); extern GLint trGet(TRcontext* tr, TRenum param); extern void trOrtho(TRcontext* tr, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); extern void trFrustum(TRcontext* tr, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); extern void trPerspective(TRcontext* tr, GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar); extern void trBeginTile(TRcontext* tr); extern int trEndTile(TRcontext* tr); extern void trRasterPos3f(TRcontext* tr, GLfloat x, GLfloat y, GLfloat z); #ifdef __cplusplus } #endif #endif mcrl2-201210.1/3rd-party/tr/doc/tr.htm000664 001751 001751 00000037274 12042421220 020307 0ustar00jenkinsjenkins000000 000000 TR - OpenGL Tile Rendering library

TR - OpenGL Tile Rendering Library

Version 1.3

Copyright (C) 1997-2005 Brian Paul



Introduction

The TR (Tile Rendering) library is an OpenGL utility library for doing tiled rendering. Tiled rendering is a technique for generating large images in pieces (tiles).

TR is memory efficient; arbitrarily large image files may be generated without allocating a full-sized image buffer in main memory.

The TR library is copyrighted by Brian Paul. See the LICENSE file for details.

You may download TR 1.3 from by SHIFT-clicking on one of the following:



Prerequisites

TR works with any version of OpenGL or Mesa. No extensions are necessary and there are no dependencies on GLX, WGL or any other window system interface.

TR is written in ANSI C and may be used from C or C++.

The TR demo programs require Mark Kilgard's GLUT library.

Users should have intermediate experience with OpenGL.



Example

The following image is divided into four rows and three columns of tiles. Note that the image size is not an exact multiple of the tile size. The TR library handles the situation in which the top row and right column are a fraction of the full tile size.

Also note that the tiles do not have to be square.

This is a small example. In reality, one may use tiles of 512 by 512 pixels and the final image may be 4000 by 3000 pixels (or larger!).



Using the Library

Ordinarily, OpenGL can't render arbitrarily large images. The maximum viewport size is typically 2K pixels or less and the window system usually imposes a maximum color buffer size.

To overcome this limitation we can render large images in pieces (tiles).

To render each tile we must carefully set the viewport and projection matrix and render the entire scene. The TR library hides the details involved in doing this. Also, TR can either automatically assemble the final image or allow the client to write the image, row by row, to a file.

The basic steps in using TR are as follows:

1. Determine where you'll render the tiles

Tiles may be rendered either in a window (front or back buffer) or in an off-screen buffer. The choice depends on your application. It doesn't matter to the TR library since TR just retrieves image tiles with glReadPixels. Just be sure glDrawBuffer and glReadBuffer are set to the same buffer.

2. Determine the destination for the final image

The final, large image may either be automatically assembed in main memory by TR or you may elect to process tiles yourself, perhaps writing them to an image file.

3. Isolate your drawing code

It should be a simple matter to completely re-render your OpenGL scene. Ideally, inside the tile rendering loop you should be able to make one function call which clears the color (and depth, etc) buffer(s) and draws your scene. If you're using a double buffered window you should not call SwapBuffers since glReadBuffer, by default, specifies the back buffer.

4. Allocate a TR context

Every TR function takes a TRcontext pointer. A TR context encapsulates the state of the library and allows one to have several TR contexts simultaneously. TR contexts are allocated with trNew.

5. Set the image and tile sizes

Call trImageSize to set the final image size, in pixels. Optionally, call trTileSize to set the tile size. The default tile size is 256 by 256 pixels with 0 border. Generally, larger tiles are better since fewer tiles (and rendering passes) will be needed.

6. Specify an image or tile buffer

If you want TR to automatically assemble the final image you must call trImageBuffer to specify an image buffer, format, and pixel type. The format and type parameters directly correspond to those used by glReadPixels.

Otherwise, if you want to process image tiles yourself you must call trTileBuffer to specify a tile buffer, format, and pixel type. The trEndTile function will copy the tile image into your buffer. You may then use or write the tile to a file, for example.

7. Optional: set tile rendering order

Since OpenGL specifies that image data are stored in bottom-to-top order TR follows the same model. However, when incrementally writing tiles to a file we usually want to do it in top-to-bottom order since that's the order used by most file formats.

The trRowOrder function allows you to specify that tiles are to be rendering in TR_TOP_TO_BOTTOM order or TR_BOTTOM_TO_TOP order. The later is the default.

8. Specify the projection

The projection matrix must be carefully controlled by TR in order to produce a final image which has no cracks or edge artifacts.

OpenGL programs typically call glFrustum, glOrtho or gluPerspective to setup the projection matrix. There are three corresponding functions in the TR library. One of them must be called to specify the projection to use. The arguments to the TR projection functions exactly match the arguments to the corresponding OpenGL functions.

9. Tile rendering loop

After the tile size and image size are specified the TR library computes how many tiles will be needed to produce the final image.

The tiles are rendered inside a loop similar to this: 

int more = 1;
while (more)
{
	trBeginTile(tr);
	DrawScene();
	more = trEndTile(tr);
}

This should be self-explanatory. Simply call trBeginTile, render your entire scene, and call trEndTile inside a loop until trEndTile returns zero.

10. Query functions

The trGet function can be called to query a number of TR state variables such as the number of rows and columns of tiles, tile size, image size, currently rendered tile, etc. See the detailed description of trGet below.

11. glRasterPos problem

The glRasterPos function is troublesome. The problem is that the current raster position is invalidated if glRasterPos results in a coordinate outside of the window. Subsequent glDrawPixels and glBitmap functions are ignored. This will frequently happen during tiled rendering resulting in flawed images.

TR includes a substitute function: trRasterPos3f which doesn't have this problem. Basically, replace calls to glRasterPos with trRasterPos. See the included demo programs for example usage.

12. Compilation

Include the tr.h header file in your client code.

Compile and link with the tr.c library source file. There is no need to compile TR as a separate library file.



API Functions

Creating and Destroying Contexts

TRcontext *trNew(void)
Return a pointer to a new TR context and initialize it. Returns NULL if out of memory.
void trDelete(TRcontext *tr)
Deallocate a TR context.

Image and Tile Setup Functions

void trTileSize(TRcontext *tr, GLint width, GLint height, GLint border)
width and height specifies size of tiles to generate. This should be no larger than the size of your window or off-screen image buffer.
border specifies how many pixels along each edge are to be uses as a border.
Borders provide overlap between adjacent tiles and are needed when drawing wide lines (width > 1) or large points (size > 1). The effective tile size is therefore width - 2 * border by height - 2 * border pixels.
void trImageSize(TRcontext *tr, GLint width, GLint height)
Specifies size of final image to generate.
void trTileBuffer(TRcontext *tr, GLenum format, GLenum type, GLvoid *image);
This is an optional function. After a tile is rendered (after trEnd) it will be copied into the buffer specified by this function.
image must point to a buffer large enough to hold an image equal to the tile size specified by trTileSize, minus any border.
format and type are interpreted in the same way as glReadPixels.
void trImageBuffer(TRcontext *tr, GLenum format, GLenum type, GLvoid *image);
This is an optional function. This specifies a buffer into which the final image is assembled.
As tiles are generated they will automatically be copied into this buffer. The image will be complete after the last tile has been rendered.
image must point to a buffer large enough to hold an image equal to the size specified by trImageSize.
format and type are interpreted in the same way as glReadPixels.

Note: trImageBuffer and trTileBuffer are the means by which image data is obtained from the TR library. You must call one (or both) of these functions in order to get output from TR.

void trRowOrder(TRcontext *tr, TRenum order)
Specifies the order in which tiles are generated.
order may take one of two values:
  • TR_BOTTOM_TO_TOP - render tiles in bottom to top order (the default)
  • TR_TOP_TO_BOTTOM - render tiles in top to bottom order

Projection Setup Functions

void trOrtho(TRcontext *tr, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far)
Specify an orthographic projection as with glOrtho.
Must be called before rendering first tile.
void trFrustum(TRcontext *tr, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far)
Specify a perspective projection as with glFrustum.
Must be called before rendering first tile.
void trPerspective(TRcontext *tr, GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar );
Specify a perspective projection as with gluPerspective.
Must be called before rendering first tile.

Tile Rendering Functions

trBeginTile(TRcontext *tr)
Begin rendering a tile.
int trEndTile(TRcontext *tr)
End rendering a tile.
Return 0 if finished rendering image.
Return 1 if more tiles remain to be rendered.

The trBeginTile and trEndTile functions are meant to be used in a loop like this: 

int more = 1;
while (more)
{
	trBeginTile(tr);
	DrawScene();
	more = trEndTile(tr);
}

DrawScene is a function which renders your OpenGL scene. It should include glClear but not SwapBuffers.

Miscellaneous Functions

GLint trGet(TRcontext *tr, TRenum param)
Query TR state. param may be one of the following:
  • TR_TILE_WIDTH - returns tile buffer width including border
  • TR_TILE_HEIGHT - returns tile buffer height including border
  • TR_TILE_BORDER - returns tile border size
  • TR_IMAGE_WIDTH - returns image buffer width
  • TR_IMAGE_HEIGHT - returns image buffer height
  • TR_ROW_ORDER - returns TR_TOP_TO_BOTTOM or TR_BOTTOM_TO_TOP
  • TR_ROWS - returns number of rows of tiles in image
  • TR_COLUMNS - returns number of columns of tiles in image
  • TR_CURRENT_ROW - returns current tile row. The bottom row is row zero.
  • TR_CURRENT_COLUMN - returns current tile column The left column is column zero.
  • TR_CURRENT_TILE_WIDTH - returns width of current tile
  • TR_CURRENT_TILE_HEIGHT - returns height of current tile

Note the difference between TR_TILE_WIDTH/HEIGHT and TR_CURRENT_TILE_WIDTH/HEIGHT. The former is the size of the tile buffer. The later is the size of the current tile which can be less than or equal to the TR_TILE_WIDTH/HEIGHT. Unless the final image size is an exact multiple of the tile size, the last tile in each row and column will be smaller than TR_TILE_WIDTH/HEIGHT.

void trRasterPos3f(TRcontext *tr, GLfloat x, GLfloat y, GLfloat z)
This function is a replacement for glRasterPos3f. The problem with the OpenGL RasterPos functions is that if the resulting window coordinate is outside the view frustum then the raster position is invalidated and glBitmap becomes a no-op.

This function avoids that problem.

You should replace calls to glRasterPos with this function. Otherwise, glRasterPos/glBitmap sequences won't work correctly during tiled rendering.

Unfortunately, trRasterPos3f can't be saved in a display list.



Notes

More on Tile Borders

A tile border should be used when drawing any of:

By using a tile border, rendering artifacts (pixel drop-outs) at tile boundaries can be eliminated.

Suppose you call glTileSize(tr, W, H, B). TR will render tiles of W by H pixels of which B pixels along each edge overlap the adjacent tiles. Therefore, the image buffer specified by calling glTileBuffer() must only be large enough to hold an image of W-2*B by H-2*B pixels.



Demonstration Programs

The TR distribution includes two GLUT-based demo programs:

You'll probably have to edit the Makefile for your computer. Compiling the demos is very simple though since they only require OpenGL and GLUT.



Contributors



Version History

Version 1.0 - April 1997

Version 1.1 - July 1997

Version 1.2 - December 2003

Version 1.3 - August 2005


Document created on April 19, 1997. Last edited on August 25, 2005. mcrl2-201210.1/3rd-party/tr/README000664 001751 001751 00000031747 12042421220 017262 0ustar00jenkinsjenkins000000 000000 TR - OpenGL Tile Rendering Library Version 1.1 Copyright (C) 1997 Brian Paul Introduction The TR (Tile Rendering) library is an OpenGL utility library for doing tiled rendering. Tiled rendering is a technique for generating large images in pieces (tiles). TR is memory efficient; arbitrarily large image files may be generated without allocating a full-sized image buffer in main memory. The TR library is copyrighted by Brian Paul. See the LICENSE file for details. You may download TR 1.1 from by SHIFT-clicking on one of the following: * tr-1.1.tar.gz (10Kbytes) * tr-1.1.zip (10Kbytes) Prerequisites TR works with any version of OpenGL or Mesa. No extensions are necessary and there are no dependencies on GLX, WGL or any other window system interface. TR is written in ANSI C and may be used from C or C++. The TR demo programs require Mark Kilgard's GLUT. Users should have intermediate experience with OpenGL. Example The following image is divided into four rows and three columns of tiles. Note that the image size is not an exact multiple of the tile size. The TR library handles the situation in which the top row and right column are a fraction of the full tile size. Also note that the tiles do not have to be square. [Image] This is a small example. In reality, one may use tiles of 512 by 512 pixels and the final image may be 4000 by 3000 pixels (or larger!). Using the Library Ordinarily, OpenGL can't render arbitrarily large images. The maximum viewport size is typically 2K pixels or less and the window system usually imposes a maximum color buffer size. To overcome this limitation we can render large images in pieces (tiles). To render each tile we must carefully set the viewport and projection matrix and render the entire scene. The TR library hides the details involved in doing this. Also, TR can either automatically assemble the final image or allow the client to write the image, row by row, to a file. The basic steps in using TR are as follows: 1. Determine where you'll render the tiles Tiles may be rendered either in a window (front or back buffer) or in an off-screen buffer. The choice depends on your application. It doesn't matter to the TR library since TR just retrieves image tiles with glReadPixels. Just be sure glDrawBuffer and glReadBuffer are set to the same buffer. 2. Determine the destination for the final image The final, large image may either be automatically assembed in main memory by TR or you may elect to process tiles yourself, perhaps writing them to an image file. 3. Isolate your drawing code It should be a simple matter to completely re-render your OpenGL scene. Ideally, inside the tile rendering loop you should be able to make one function call which clears the color (and depth, etc) buffer(s) and draws your scene. If you're using a double buffered window you should not call SwapBuffers since glReadBuffer, by default, specifies the back buffer. 4. Allocate a TR context Every TR function takes a TRcontext pointer. A TR context encapsulates the state of the library and allows one to have several TR contexts simultaneously. TR contexts are allocated with trNew. 5. Set the image and tile sizes Call trImageSize to set the final image size, in pixels. Optionally, call trTileSize to set the tile size. The default tile size is 256 by 256 pixels with 0 border. Generally, larger tiles are better since fewer tiles (and rendering passes) will be needed. 6. Specify an image or tile buffer If you want TR to automatically assemble the final image you must call trImageBuffer to specify an image buffer, format, and pixel type. The format and type parameters directly correspond to those used by glReadPixels. Otherwise, if you want to process image tiles yourself you must call trTileBuffer to specify a tile buffer, format, and pixel type. The trEndTile function will copy the tile image into your buffer. You may then use or write the tile to a file, for example. 7. Optional: set tile rendering order Since OpenGL specifies that image data are stored in bottom-to-top order TR follows the same model. However, when incrementally writing tiles to a file we usually want to do it in top-to-bottom order since that's the order used by most file formats. The trRowOrder function allows you to specify that tiles are to be rendering in TR_TOP_TO_BOTTOM order or TR_BOTTOM_TO_TOP order. The later is the default. 8. Specify the projection The projection matrix must be carefully controlled by TR in order to produce a final image which has no cracks or edge artifacts. OpenGL programs typically call glFrustum, glOrtho or gluPerspective to setup the projection matrix. There are three corresponding functions in the TR library. One of them must be called to specify the projection to use. The arguments to the TR projection functions exactly match the arguments to the corresponding OpenGL functions. 9. Tile rendering loop After the tile size and image size are specified the TR library computes how many tiles will be needed to produce the final image. The tiles are rendered inside a loop similar to this: int more = 1; while (more) { trBeginTile(tr); DrawScene(); more = trEndTile(tr); } This should be self-explanatory. Simply call trBeginTile, render your entire scene, and call trEndTile inside a loop until trEndTile returns zero. 10. Query functions The trGet function can be called to query a number of TR state variables such as the number of rows and columns of tiles, tile size, image size, currently rendered tile, etc. See the detailed description of trGet below. 11. glRasterPos problem The glRasterPos function is troublesome. The problem is that the current raster position is invalidated if glRasterPos results in a coordinate outside of the window. Subsequent glDrawPixels and glBitmap functions are ignored. This will frequently happen during tiled rendering resulting in flawed images. TR includes a substitute function: trRasterPos3f which doesn't have this problem. Basically, replace calls to glRasterPos with trRasterPos. See the included demo programs for example usage. 12. Compilation Include the tr.h header file in your client code. Compile and link with the tr.c library source file. There is no need to compile TR as a separate library file. API Functions Creating and Destroying Contexts TRcontext *trNew(void) Return a pointer to a new TR context and initialize it. Returns NULL if out of memory. void trDelete(TRcontext *tr) Deallocate a TR context. Image and Tile Setup Functions void trTileSize(TRcontext *tr, GLint width, GLint height, GLint border) width and height specifies size of tiles to generate. This should be no larger than the size of your window or off-screen image buffer. border specifies how many pixels along each edge are to be uses as a border. Borders provide overlap between adjacent tiles and are needed when drawing wide lines (width > 1) or large points (size > 1). The effective tile size is therefore width - 2 * border by height - 2 * border pixels. void trImageSize(TRcontext *tr, GLint width, GLint height) Specifies size of final image to generate. void trTileBuffer(TRcontext *tr, GLenum format, GLenum type, GLvoid *image); This is an optional function. After a tile is rendered (after trEnd) it will be copied into the buffer specified by this function. image must point to a buffer large enough to hold an image equal to the tile size specified by trTileSize, minus any border. format and type are interpreted in the same way as glReadPixels. void trImageBuffer(TRcontext *tr, GLenum format, GLenum type, GLvoid *image); This is an optional function. This specifies a buffer into which the final image is assembled. As tiles are generated they will automatically be copied into this buffer. The image will be complete after the last tile has been rendered. image must point to a buffer large enough to hold an image equal to the size specified by trImageSize. format and type are interpreted in the same way as glReadPixels. Note: trImageBuffer and trTileBuffer are the means by which image data is obtained from the TR library. You must call one (or both) of these functions in order to get output from TR. void trRowOrder(TRcontext *tr, TRenum order) Specifies the order in which tiles are generated. order may take one of two values: o TR_BOTTOM_TO_TOP - render tiles in bottom to top order (the default) o TR_TOP_TO_BOTTOM - render tiles in top to bottom order Projection Setup Functions void trOrtho(TRcontext *tr, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far) Specify an orthographic projection as with glOrtho. Must be called before rendering first tile. void trFrustum(TRcontext *tr, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far) Specify a perspective projection as with glFrustum. Must be called before rendering first tile. void trPerspective(TRcontext *tr, GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar ); Specify a perspective projection as with gluPerspective. Must be called before rendering first tile. Tile Rendering Functions trBeginTile(TRcontext *tr) Begin rendering a tile. int trEndTile(TRcontext *tr) End rendering a tile. Return 0 if finished rendering image. Return 1 if more tiles remain to be rendered. The trBeginTile and trEndTile functions are meant to be used in a loop like this: int more = 1; while (more) { trBeginTile(tr); DrawScene(); more = trEndTile(tr); } DrawScene is a function which renders your OpenGL scene. It should include glClear but not SwapBuffers. Miscellaneous Functions GLint trGet(TRcontext *tr, TRenum param) Query TR state. param may be one of the following: o TR_TILE_WIDTH - returns tile buffer width including border o TR_TILE_HEIGHT - returns tile buffer height including border o TR_TILE_BORDER - returns tile border size o TR_IMAGE_WIDTH - returns image buffer width o TR_IMAGE_HEIGHT - returns image buffer height o TR_ROW_ORDER - returns TR_TOP_TO_BOTTOM or TR_BOTTOM_TO_TOP o TR_ROWS - returns number of rows of tiles in image o TR_COLUMNS - returns number of columns of tiles in image o TR_CURRENT_ROW - returns current tile row. The bottom row is row zero. o TR_CURRENT_COLUMN - returns current tile column The left column is column zero. o TR_CURRENT_TILE_WIDTH - returns width of current tile o TR_CURRENT_TILE_HEIGHT - returns height of current tile Note the difference between TR_TILE_WIDTH/HEIGHT and TR_CURRENT_TILE_WIDTH/HEIGHT. The former is the size of the tile buffer. The later is the size of the current tile which can be less than or equal to the TR_TILE_WIDTH/HEIGHT. Unless the final image size is an exact multiple of the tile size, the last tile in each row and column will be smaller than TR_TILE_WIDTH/HEIGHT. void trRasterPos3f(TRcontext *tr, GLfloat x, GLfloat y, GLfloat z) This function is a replacement for glRasterPos3f. The problem with the OpenGL RasterPos functions is that if the resulting window coordinate is outside the view frustum then the raster position is invalidated and glBitmap becomes a no-op. This function avoids that problem. You should replace calls to glRasterPos with this function. Otherwise, glRasterPos/glBitmap sequences won't work correctly during tiled rendering. Unfortunately, trRasterPos3f can't be saved in a display list. Notes More on Tile Borders A tile border should be used when drawing any of: * wide lines (width > 1) * large points (width > 1) * antialiased lines or points * GL_POINT or GL_LINE polygon modes By using a tile border, rendering artifacts (pixel drop-outs) at tile boundaries can be eliminated. Suppose you call glTileSize(tr, W, H, B). TR will render tiles of W by H pixels of which B pixels along each edge overlap the adjacent tiles. Therefore, the image buffer specified by calling glTileBuffer() must only be large enough to hold an image of W-2*B by H-2*B pixels. Demonstration Programs The TR distribution includes two GLUT-based demo programs: * trdemo1 - renders a window-size image in tiles * trdemo2 - produces a large PPM file incrementally You'll probably have to edit the Makefile for your computer. Compiling the demos is very simple though since they only require OpenGL and GLUT. Contributors * Robin Syllwasschy - provided much helpful feedback for the initial version of TR. Version History Version 1.0 - April 1997 * Initial version Version 1.1 - July 1997 * Added tile border support * Fixed a few compilation problems ---------------------------------------------------------------------------- Document created on April 19, 1997. Last edited on January 24, 1999. mcrl2-201210.1/3rd-party/tr/CMakeLists.txt000664 001751 001751 00000001644 12042421220 021133 0ustar00jenkinsjenkins000000 000000 # Authors: Frank Stappers and Aad Mathijssen # Copyright: see the accompanying file COPYING or copy at # https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING # # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) # ########## Project setup ########## project(tr) cmake_minimum_required(VERSION 2.6) # ######### General setup ########## # Trick to add header files to projects in IDEs like Visual Studio and XCode FILE(GLOB HEADERS "include/tr/*.h") add_custom_target(${PROJECT_NAME}_headers SOURCES ${HEADERS} ${DETAIL_HEADERS} ) # actual target: add_library(${PROJECT_NAME} source/tr.c ) target_link_libraries(${PROJECT_NAME} ${OPENGL_LIBRARY} ) include_directories(${CMAKE_SOURCE_DIR}/3rd-party/tr/include/tr) # add install target: install(TARGETS ${PROJECT_NAME} DESTINATION ${MCRL2_LIB_DIR} COMPONENT Libraries) mcrl2-201210.1/3rd-party/tr/source/tr.c000664 001751 001751 00000027124 12042421220 020465 0ustar00jenkinsjenkins000000 000000 /* $Id: tr.c,v 1.9 1998/01/29 16:56:54 brianp Exp $ */ /* * $Log: tr.c,v $ * Revision 1.9 1998/01/29 16:56:54 brianp * allow trOrtho() and trFrustum() to be called at any time, minor clean-up * * Revision 1.8 1998/01/28 19:47:39 brianp * minor clean-up for C++ * * Revision 1.7 1997/07/21 17:34:38 brianp * added tile borders * * Revision 1.6 1997/07/21 15:47:35 brianp * renamed all "near" and "far" variables * * Revision 1.5 1997/04/26 21:23:25 brianp * added trRasterPos3f function * * Revision 1.4 1997/04/26 19:59:36 brianp * set CurrentTile to -1 before first tile and after last tile * * Revision 1.3 1997/04/22 23:51:15 brianp * added WIN32 header stuff, removed tabs * * Revision 1.2 1997/04/19 23:26:10 brianp * many API changes * * Revision 1.1 1997/04/18 21:53:05 brianp * Initial revision * */ /* * Tiled Rendering library * Version 1.3 * Copyright (C) Brian Paul */ #include #include #include #include #ifdef WIN32 #include #endif #ifdef __APPLE__ #include #include #else #include #include #endif #include "tr.h" #define DEFAULT_TILE_WIDTH 256 #define DEFAULT_TILE_HEIGHT 256 #define DEFAULT_TILE_BORDER 0 struct _TRctx { /* Final image parameters */ GLint ImageWidth, ImageHeight; GLenum ImageFormat, ImageType; GLvoid* ImageBuffer; /* Tile parameters */ GLint TileWidth, TileHeight; GLint TileWidthNB, TileHeightNB; GLint TileBorder; GLenum TileFormat, TileType; GLvoid* TileBuffer; /* Projection parameters */ GLboolean Perspective; GLdouble Left; GLdouble Right; GLdouble Bottom; GLdouble Top; GLdouble Near; GLdouble Far; /* Misc */ TRenum RowOrder; GLint Rows, Columns; GLint CurrentTile; GLint CurrentTileWidth, CurrentTileHeight; GLint CurrentRow, CurrentColumn; GLint ViewportSave[4]; }; /* * Misc setup including computing number of tiles (rows and columns). */ static void Setup(TRcontext* tr) { if (!tr) { return; } tr->Columns = (tr->ImageWidth + tr->TileWidthNB - 1) / tr->TileWidthNB; tr->Rows = (tr->ImageHeight + tr->TileHeightNB - 1) / tr->TileHeightNB; tr->CurrentTile = 0; assert(tr->Columns >= 0); assert(tr->Rows >= 0); } TRcontext* trNew(void) { TRcontext* tr = (TRcontext*) calloc(1, sizeof(TRcontext)); if (tr) { tr->TileWidth = DEFAULT_TILE_WIDTH; tr->TileHeight = DEFAULT_TILE_HEIGHT; tr->TileBorder = DEFAULT_TILE_BORDER; tr->RowOrder = TR_BOTTOM_TO_TOP; tr->CurrentTile = -1; } return (TRcontext*) tr; } void trDelete(TRcontext* tr) { if (tr) { free(tr); } } void trTileSize(TRcontext* tr, GLint width, GLint height, GLint border) { if (!tr) { return; } assert(border >= 0); assert(width >= 1); assert(height >= 1); assert(width >= 2*border); assert(height >= 2*border); tr->TileBorder = border; tr->TileWidth = width; tr->TileHeight = height; tr->TileWidthNB = width - 2 * border; tr->TileHeightNB = height - 2 * border; Setup(tr); } void trTileBuffer(TRcontext* tr, GLenum format, GLenum type, GLvoid* image) { if (!tr) { return; } tr->TileFormat = format; tr->TileType = type; tr->TileBuffer = image; } void trImageSize(TRcontext* tr, GLint width, GLint height) { if (!tr) { return; } tr->ImageWidth = width; tr->ImageHeight = height; Setup(tr); } void trImageBuffer(TRcontext* tr, GLenum format, GLenum type, GLvoid* image) { if (!tr) { return; } tr->ImageFormat = format; tr->ImageType = type; tr->ImageBuffer = image; } GLint trGet(TRcontext* tr, TRenum param) { if (!tr) { return 0; } switch (param) { case TR_TILE_WIDTH: return tr->TileWidth; case TR_TILE_HEIGHT: return tr->TileHeight; case TR_TILE_BORDER: return tr->TileBorder; case TR_IMAGE_WIDTH: return tr->ImageWidth; case TR_IMAGE_HEIGHT: return tr->ImageHeight; case TR_ROWS: return tr->Rows; case TR_COLUMNS: return tr->Columns; case TR_CURRENT_ROW: if (tr->CurrentTile<0) { return -1; } else { return tr->CurrentRow; } case TR_CURRENT_COLUMN: if (tr->CurrentTile<0) { return -1; } else { return tr->CurrentColumn; } case TR_CURRENT_TILE_WIDTH: return tr->CurrentTileWidth; case TR_CURRENT_TILE_HEIGHT: return tr->CurrentTileHeight; case TR_ROW_ORDER: return (GLint) tr->RowOrder; default: return 0; } } void trRowOrder(TRcontext* tr, TRenum order) { if (!tr) { return; } if (order==TR_TOP_TO_BOTTOM || order==TR_BOTTOM_TO_TOP) { tr->RowOrder = order; } } void trOrtho(TRcontext* tr, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) { if (!tr) { return; } tr->Perspective = GL_FALSE; tr->Left = left; tr->Right = right; tr->Bottom = bottom; tr->Top = top; tr->Near = zNear; tr->Far = zFar; } void trFrustum(TRcontext* tr, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) { if (!tr) { return; } tr->Perspective = GL_TRUE; tr->Left = left; tr->Right = right; tr->Bottom = bottom; tr->Top = top; tr->Near = zNear; tr->Far = zFar; } void trPerspective(TRcontext* tr, GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar) { GLdouble xmin, xmax, ymin, ymax; ymax = zNear * tan(fovy * 3.14159265 / 360.0); ymin = -ymax; xmin = ymin * aspect; xmax = ymax * aspect; trFrustum(tr, xmin, xmax, ymin, ymax, zNear, zFar); } void trBeginTile(TRcontext* tr) { GLint matrixMode; GLint tileWidth, tileHeight, border; GLdouble left, right, bottom, top; if (!tr) { return; } if (tr->CurrentTile <= 0) { Setup(tr); /* Save user's viewport, will be restored after last tile rendered */ glGetIntegerv(GL_VIEWPORT, tr->ViewportSave); } /* which tile (by row and column) we're about to render */ if (tr->RowOrder==TR_BOTTOM_TO_TOP) { tr->CurrentRow = tr->CurrentTile / tr->Columns; tr->CurrentColumn = tr->CurrentTile % tr->Columns; } else if (tr->RowOrder==TR_TOP_TO_BOTTOM) { tr->CurrentRow = tr->Rows - (tr->CurrentTile / tr->Columns) - 1; tr->CurrentColumn = tr->CurrentTile % tr->Columns; } else { /* This should never happen */ abort(); } assert(tr->CurrentRow < tr->Rows); assert(tr->CurrentColumn < tr->Columns); border = tr->TileBorder; /* Compute actual size of this tile with border */ if (tr->CurrentRow < tr->Rows-1) { tileHeight = tr->TileHeight; } else { tileHeight = tr->ImageHeight - (tr->Rows-1) * (tr->TileHeightNB) + 2 * border; } if (tr->CurrentColumn < tr->Columns-1) { tileWidth = tr->TileWidth; } else { tileWidth = tr->ImageWidth - (tr->Columns-1) * (tr->TileWidthNB) + 2 * border; } /* Save tile size, with border */ tr->CurrentTileWidth = tileWidth; tr->CurrentTileHeight = tileHeight; glViewport(0, 0, tileWidth, tileHeight); /* tile size including border */ /* save current matrix mode */ glGetIntegerv(GL_MATRIX_MODE, &matrixMode); glMatrixMode(GL_PROJECTION); glLoadIdentity(); /* compute projection parameters */ left = tr->Left + (tr->Right - tr->Left) * (tr->CurrentColumn * tr->TileWidthNB - border) / tr->ImageWidth; right = left + (tr->Right - tr->Left) * tileWidth / tr->ImageWidth; bottom = tr->Bottom + (tr->Top - tr->Bottom) * (tr->CurrentRow * tr->TileHeightNB - border) / tr->ImageHeight; top = bottom + (tr->Top - tr->Bottom) * tileHeight / tr->ImageHeight; if (tr->Perspective) { glFrustum(left, right, bottom, top, tr->Near, tr->Far); } else { glOrtho(left, right, bottom, top, tr->Near, tr->Far); } /* restore user's matrix mode */ glMatrixMode(matrixMode); } int trEndTile(TRcontext* tr) { GLint prevRowLength, prevSkipRows, prevSkipPixels; if (!tr) { return 0; } assert(tr->CurrentTile>=0); /* be sure OpenGL rendering is finished */ glFlush(); /* save current glPixelStore values */ glGetIntegerv(GL_PACK_ROW_LENGTH, &prevRowLength); glGetIntegerv(GL_PACK_SKIP_ROWS, &prevSkipRows); glGetIntegerv(GL_PACK_SKIP_PIXELS, &prevSkipPixels); /*glGetIntegerv(GL_PACK_ALIGNMENT, &prevAlignment);*/ if (tr->TileBuffer) { GLint srcX = tr->TileBorder; GLint srcY = tr->TileBorder; GLint srcWidth = tr->TileWidthNB; GLint srcHeight = tr->TileHeightNB; glReadPixels(srcX, srcY, srcWidth, srcHeight, tr->TileFormat, tr->TileType, tr->TileBuffer); } if (tr->ImageBuffer) { GLint srcX = tr->TileBorder; GLint srcY = tr->TileBorder; GLint srcWidth = tr->CurrentTileWidth - 2 * tr->TileBorder; GLint srcHeight = tr->CurrentTileHeight - 2 * tr->TileBorder; GLint destX = tr->TileWidthNB * tr->CurrentColumn; GLint destY = tr->TileHeightNB * tr->CurrentRow; /* setup pixel store for glReadPixels */ glPixelStorei(GL_PACK_ROW_LENGTH, tr->ImageWidth); glPixelStorei(GL_PACK_SKIP_ROWS, destY); glPixelStorei(GL_PACK_SKIP_PIXELS, destX); /*glPixelStorei(GL_PACK_ALIGNMENT, 1);*/ /* read the tile into the final image */ glReadPixels(srcX, srcY, srcWidth, srcHeight, tr->ImageFormat, tr->ImageType, tr->ImageBuffer); } /* restore previous glPixelStore values */ glPixelStorei(GL_PACK_ROW_LENGTH, prevRowLength); glPixelStorei(GL_PACK_SKIP_ROWS, prevSkipRows); glPixelStorei(GL_PACK_SKIP_PIXELS, prevSkipPixels); /*glPixelStorei(GL_PACK_ALIGNMENT, prevAlignment);*/ /* increment tile counter, return 1 if more tiles left to render */ tr->CurrentTile++; if (tr->CurrentTile >= tr->Rows * tr->Columns) { /* restore user's viewport */ glViewport(tr->ViewportSave[0], tr->ViewportSave[1], tr->ViewportSave[2], tr->ViewportSave[3]); tr->CurrentTile = -1; /* all done */ return 0; } else { return 1; } } /* * Replacement for glRastePos3f() which avoids the problem with invalid * raster pos. */ void trRasterPos3f(TRcontext* tr, GLfloat x, GLfloat y, GLfloat z) { if (tr->CurrentTile<0) { /* not doing tile rendering right now. Let OpenGL do this. */ glRasterPos3f(x, y, z); } else { GLdouble modelview[16], proj[16]; GLint viewport[4]; GLdouble winX, winY, winZ; /* Get modelview, projection and viewport */ glGetDoublev(GL_MODELVIEW_MATRIX, modelview); glGetDoublev(GL_PROJECTION_MATRIX, proj); viewport[0] = 0; viewport[1] = 0; viewport[2] = tr->CurrentTileWidth; viewport[3] = tr->CurrentTileHeight; /* Project object coord to window coordinate */ if (gluProject(x, y, z, modelview, proj, viewport, &winX, &winY, &winZ)) { /* set raster pos to window coord (0,0) */ glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrtho(0.0, tr->CurrentTileWidth, 0.0, tr->CurrentTileHeight, 0.0, 1.0); glRasterPos3f(0.0, 0.0, (GLfloat) -winZ); /* Now use empty bitmap to adjust raster position to (winX,winY) */ { GLubyte bitmap[1] = {0}; glBitmap(1, 1, 0.0, 0.0, (GLfloat) winX, (GLfloat) winY, bitmap); } /* restore original matrices */ glPopMatrix(); /*proj*/ glMatrixMode(GL_MODELVIEW); glPopMatrix(); } #ifdef DEBUG if (glGetError()) { printf("GL error!\n"); } #endif } } mcrl2-201210.1/3rd-party/tr/LICENSE000664 001751 001751 00000061263 12042421220 017403 0ustar00jenkinsjenkins000000 000000 GNU LIBRARY GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1991 Free Software Foundation, Inc. 675 Mass Ave, Cambridge, MA 02139, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the library GPL. It is numbered 2 because it goes with version 2 of the ordinary GPL.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Library General Public License, applies to some specially designated Free Software Foundation software, and to any other libraries whose authors decide to use it. You can use it for your libraries, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library, or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link a program with the library, you must provide complete object files to the recipients so that they can relink them with the library, after making changes to the library and recompiling it. And you must show them these terms so they know their rights. Our method of protecting your rights has two steps: (1) copyright the library, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the library. Also, for each distributor's protection, we want to make certain that everyone understands that there is no warranty for this free library. If the library is modified by someone else and passed on, we want its recipients to know that what they have is not the original version, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that companies distributing free software will individually obtain patent licenses, thus in effect transforming the program into proprietary software. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License, which was designed for utility programs. This license, the GNU Library General Public License, applies to certain designated libraries. This license is quite different from the ordinary one; be sure to read it in full, and don't assume that anything in it is the same as in the ordinary license. The reason we have a separate public license for some libraries is that they blur the distinction we usually make between modifying or adding to a program and simply using it. Linking a program with a library, without changing the library, is in some sense simply using the library, and is analogous to running a utility program or application program. However, in a textual and legal sense, the linked executable is a combined work, a derivative of the original library, and the ordinary General Public License treats it as such. Because of this blurred distinction, using the ordinary General Public License for libraries did not effectively promote software sharing, because most developers did not use the libraries. We concluded that weaker conditions might promote sharing better. However, unrestricted linking of non-free programs would deprive the users of those programs of all benefit from the free status of the libraries themselves. This Library General Public License is intended to permit developers of non-free programs to use free libraries, while preserving your freedom as a user of such programs to change the free libraries that are incorporated in them. (We have not seen how to achieve this as regards changes in header files, but we have achieved it as regards changes in the actual functions of the Library.) The hope is that this will lead to faster development of free libraries. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, while the latter only works together with the library. Note that it is possible for a library to be covered by the ordinary General Public License rather than by this special one. GNU LIBRARY GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Library General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also compile or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. c) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. d) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Library General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS Appendix: How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Also add information on how to contact you by electronic and paper mail. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker. , 1 April 1990 Ty Coon, President of Vice That's all there is to it! mcrl2-201210.1/3rd-party/gl2ps/include/gl2ps/gl2ps.h000664 001751 001751 00000014704 12042421220 022650 0ustar00jenkinsjenkins000000 000000 /* * GL2PS, an OpenGL to PostScript Printing Library * Copyright (C) 1999-2009 C. Geuzaine * * This program is free software; you can redistribute it and/or * modify it under the terms of either: * * a) the GNU Library General Public License as published by the Free * Software Foundation, either version 2 of the License, or (at your * option) any later version; or * * b) the GL2PS License as published by Christophe Geuzaine, either * version 2 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 either * the GNU Library General Public License or the GL2PS License for * more details. * * You should have received a copy of the GNU Library General Public * License along with this library in the file named "COPYING.LGPL"; * if not, write to the Free Software Foundation, Inc., 675 Mass Ave, * Cambridge, MA 02139, USA. * * You should have received a copy of the GL2PS License with this * library in the file named "COPYING.GL2PS"; if not, I will be glad * to provide one. * * For the latest info about gl2ps and a full list of contributors, * see http://www.geuz.org/gl2ps/. * * Please report all bugs and problems to . */ #ifndef __GL2PS_H__ #define __GL2PS_H__ #include #include /* Define GL2PSDLL at compile time to build a Windows DLL */ #if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__) # if defined(_MSC_VER) # pragma warning(disable:4115) # pragma warning(disable:4996) # endif # include # if defined(GL2PSDLL) # if defined(GL2PSDLL_EXPORTS) # define GL2PSDLL_API __declspec(dllexport) # else # define GL2PSDLL_API __declspec(dllimport) # endif # else # define GL2PSDLL_API # endif #else # define GL2PSDLL_API #endif #if defined(__APPLE__) || defined(HAVE_OPENGL_GL_H) # include #else # include #endif /* Support for compressed PostScript/PDF/SVG and for embedded PNG images in SVG */ #if defined(HAVE_ZLIB) || defined(HAVE_LIBZ) # define GL2PS_HAVE_ZLIB # if defined(HAVE_LIBPNG) || defined(HAVE_PNG) # define GL2PS_HAVE_LIBPNG # endif #endif /* Version number */ #define GL2PS_MAJOR_VERSION 1 #define GL2PS_MINOR_VERSION 3 #define GL2PS_PATCH_VERSION 5 #define GL2PS_EXTRA_VERSION "" #define GL2PS_VERSION (GL2PS_MAJOR_VERSION + \ 0.01 * GL2PS_MINOR_VERSION + \ 0.0001 * GL2PS_PATCH_VERSION) #define GL2PS_COPYRIGHT "(C) 1999-2009 C. Geuzaine" /* Output file formats (the values and the ordering are important!) */ #define GL2PS_PS 0 #define GL2PS_EPS 1 #define GL2PS_TEX 2 #define GL2PS_PDF 3 #define GL2PS_SVG 4 #define GL2PS_PGF 5 /* Sorting algorithms */ #define GL2PS_NO_SORT 1 #define GL2PS_SIMPLE_SORT 2 #define GL2PS_BSP_SORT 3 /* Message levels and error codes */ #define GL2PS_SUCCESS 0 #define GL2PS_INFO 1 #define GL2PS_WARNING 2 #define GL2PS_ERROR 3 #define GL2PS_NO_FEEDBACK 4 #define GL2PS_OVERFLOW 5 #define GL2PS_UNINITIALIZED 6 /* Options for gl2psBeginPage */ #define GL2PS_NONE 0 #define GL2PS_DRAW_BACKGROUND (1<<0) #define GL2PS_SIMPLE_LINE_OFFSET (1<<1) #define GL2PS_SILENT (1<<2) #define GL2PS_BEST_ROOT (1<<3) #define GL2PS_OCCLUSION_CULL (1<<4) #define GL2PS_NO_TEXT (1<<5) #define GL2PS_LANDSCAPE (1<<6) #define GL2PS_NO_PS3_SHADING (1<<7) #define GL2PS_NO_PIXMAP (1<<8) #define GL2PS_USE_CURRENT_VIEWPORT (1<<9) #define GL2PS_COMPRESS (1<<10) #define GL2PS_NO_BLENDING (1<<11) #define GL2PS_TIGHT_BOUNDING_BOX (1<<12) /* Arguments for gl2psEnable/gl2psDisable */ #define GL2PS_POLYGON_OFFSET_FILL 1 #define GL2PS_POLYGON_BOUNDARY 2 #define GL2PS_LINE_STIPPLE 3 #define GL2PS_BLEND 4 /* Text alignment (o=raster position; default mode is BL): +---+ +---+ +---+ +---+ +---+ +---+ +-o-+ o---+ +---o | o | o | | o | | | | | | | | | | | | +---+ +---+ +---+ +-o-+ o---+ +---o +---+ +---+ +---+ C CL CR B BL BR T TL TR */ #define GL2PS_TEXT_C 1 #define GL2PS_TEXT_CL 2 #define GL2PS_TEXT_CR 3 #define GL2PS_TEXT_B 4 #define GL2PS_TEXT_BL 5 #define GL2PS_TEXT_BR 6 #define GL2PS_TEXT_T 7 #define GL2PS_TEXT_TL 8 #define GL2PS_TEXT_TR 9 typedef GLfloat GL2PSrgba[4]; #if defined(__cplusplus) extern "C" { #endif GL2PSDLL_API GLint gl2psBeginPage(const char* title, const char* producer, GLint viewport[4], GLint format, GLint sort, GLint options, GLint colormode, GLint colorsize, GL2PSrgba* colormap, GLint nr, GLint ng, GLint nb, GLint buffersize, FILE* stream, const char* filename); GL2PSDLL_API GLint gl2psEndPage(void); GL2PSDLL_API GLint gl2psSetOptions(GLint options); GL2PSDLL_API GLint gl2psGetOptions(GLint* options); GL2PSDLL_API GLint gl2psBeginViewport(GLint viewport[4]); GL2PSDLL_API GLint gl2psEndViewport(void); GL2PSDLL_API GLint gl2psText(const char* str, const char* fontname, GLshort fontsize); GL2PSDLL_API GLint gl2psTextOpt(const char* str, const char* fontname, GLshort fontsize, GLint align, GLfloat angle); GL2PSDLL_API GLint gl2psSpecial(GLint format, const char* str); GL2PSDLL_API GLint gl2psDrawPixels(GLsizei width, GLsizei height, GLint xorig, GLint yorig, GLenum format, GLenum type, const void* pixels); GL2PSDLL_API GLint gl2psEnable(GLint mode); GL2PSDLL_API GLint gl2psDisable(GLint mode); GL2PSDLL_API GLint gl2psPointSize(GLfloat value); GL2PSDLL_API GLint gl2psLineWidth(GLfloat value); GL2PSDLL_API GLint gl2psBlendFunc(GLenum sfactor, GLenum dfactor); /* undocumented */ GL2PSDLL_API GLint gl2psDrawImageMap(GLsizei width, GLsizei height, const GLfloat position[3], const unsigned char* imagemap); GL2PSDLL_API const char* gl2psGetFileExtension(GLint format); GL2PSDLL_API const char* gl2psGetFormatDescription(GLint format); #if defined(__cplusplus) } #endif #endif /* __GL2PS_H__ */ mcrl2-201210.1/3rd-party/gl2ps/COPYING.GL2PS000664 001751 001751 00000001700 12042421220 020647 0ustar00jenkinsjenkins000000 000000 GL2PS LICENSE Version 2, November 2003 Copyright (C) 2003, Christophe Geuzaine Permission to use, copy, and distribute this software and its documentation for any purpose with or without fee is hereby granted, provided that the copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. Permission to modify and distribute modified versions of this software is granted, provided that: 1) the modifications are licensed under the same terms as this software; 2) you make available the source code of any modifications that you distribute, either on the same media as you distribute any executable or other form of this software, or via a mechanism generally accepted in the software development community for the electronic transfer of data. This software is provided "as is" without express or implied warranty. mcrl2-201210.1/3rd-party/gl2ps/doc/gl2ps.pdf000664 001751 001751 00000525771 12042421220 021300 0ustar00jenkinsjenkins000000 000000 %PDF-1.4 %ÐÔÅØ 5 0 obj << /S /GoTo /D (section.1) >> endobj 8 0 obj (Introduction) endobj 9 0 obj << /S /GoTo /D (section.2) >> endobj 12 0 obj (Usage) endobj 13 0 obj << /S /GoTo /D (subsection.2.1) >> endobj 16 0 obj (gl2psBeginPage and gl2psEndPage) endobj 17 0 obj << /S /GoTo /D (subsection.2.2) >> endobj 20 0 obj (gl2psText and gl2psTextOpt) endobj 21 0 obj << /S /GoTo /D (subsection.2.3) >> endobj 24 0 obj (gl2psDrawPixels) endobj 25 0 obj << /S /GoTo /D (subsection.2.4) >> endobj 28 0 obj (gl2psSpecial) endobj 29 0 obj << /S /GoTo /D (subsection.2.5) >> endobj 32 0 obj (gl2psEnable and gl2psDisable) endobj 33 0 obj << /S /GoTo /D (subsection.2.6) >> endobj 36 0 obj (gl2psPointSize and gl2psLineWidth) endobj 37 0 obj << /S /GoTo /D (subsection.2.7) >> endobj 40 0 obj (gl2psBlendFunc) endobj 41 0 obj << /S /GoTo /D (subsection.2.8) >> endobj 44 0 obj (gl2psBeginViewport and gl2psEndViewport) endobj 45 0 obj << /S /GoTo /D (subsection.2.9) >> endobj 48 0 obj (gl2psSetOptions and gl2psGetOptions) endobj 49 0 obj << /S /GoTo /D (section.3) >> endobj 52 0 obj (Example) endobj 53 0 obj << /S /GoTo /D (section.4) >> endobj 56 0 obj (Tips and tricks) endobj 57 0 obj << /S /GoTo /D (section.5) >> endobj 60 0 obj (Limitations) endobj 61 0 obj << /S /GoTo /D (section.6) >> endobj 64 0 obj (Contributors) endobj 65 0 obj << /S /GoTo /D (section.7) >> endobj 68 0 obj (Links) endobj 69 0 obj << /S /GoTo /D (section.8) >> endobj 72 0 obj (Versions) endobj 73 0 obj << /S /GoTo /D [74 0 R /Fit ] >> endobj 94 0 obj << /Length 1156 /Filter /FlateDecode >> stream xÚŘMoã6†ïù:Ê@Ír(~ö¸Ù¬Ñ"@‚ÆMÙ›±‰*’*É›týE¹±%'VŠ ¹˜=|9|8"9¤Ñ*¢Ñì„>S~šŸüüDŠ0<šßE DGI ‹æËè&ž³Ë«_&Ó„²8ÍCyQN¦LÆ6Ÿ‡Š¦åå„©¸¨›«EåÊ&Ô••Ë'hݸ|5ùkþ[L¡x4e@ èÐMæn«´ú× [2üOæÝBµF{M´`º®\ÝåÚb/¨>³›ï©ËmÛÃ{á[$„sZ\O4‹mU»Âý’ñSh~±hŠ[”B‹P2X1JMðŠ¡Wœ$\¯LB˜Á>š¬SÔN nl(jßð7ªU~Ÿ!x¦"CŒDI”¢û(`25LÄ¿¢’­> endobj 75 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [132.772 460.371 212.874 469.282] /Subtype /Link /A << /S /GoTo /D (section.1) >> >> endobj 76 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [132.772 436.516 179.591 447.281] /Subtype /Link /A << /S /GoTo /D (section.2) >> >> endobj 77 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [147.716 424.284 331.304 435.409] /Subtype /Link /A << /S /GoTo /D (subsection.2.1) >> >> endobj 78 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [147.716 412.329 305.153 423.454] /Subtype /Link /A << /S /GoTo /D (subsection.2.2) >> >> endobj 79 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [147.716 400.374 251.078 411] /Subtype /Link /A << /S /GoTo /D (subsection.2.3) >> >> endobj 80 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [147.716 388.418 235.387 399.045] /Subtype /Link /A << /S /GoTo /D (subsection.2.4) >> >> endobj 81 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [147.716 376.463 315.613 387.588] /Subtype /Link /A << /S /GoTo /D (subsection.2.5) >> >> endobj 82 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [147.716 364.508 341.765 375.633] /Subtype /Link /A << /S /GoTo /D (subsection.2.6) >> >> endobj 83 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [147.716 352.553 245.847 363.18] /Subtype /Link /A << /S /GoTo /D (subsection.2.7) >> >> endobj 84 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [147.716 340.598 373.147 351.723] /Subtype /Link /A << /S /GoTo /D (subsection.2.8) >> >> endobj 85 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [147.716 328.642 352.226 339.767] /Subtype /Link /A << /S /GoTo /D (subsection.2.9) >> >> endobj 86 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [132.772 307.001 193.198 317.85] /Subtype /Link /A << /S /GoTo /D (section.3) >> >> endobj 87 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [132.772 285.084 225.379 295.932] /Subtype /Link /A << /S /GoTo /D (section.4) >> >> endobj 88 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [132.772 265.103 206.787 274.014] /Subtype /Link /A << /S /GoTo /D (section.5) >> >> endobj 89 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [132.772 243.185 214.266 252.096] /Subtype /Link /A << /S /GoTo /D (section.6) >> >> endobj 90 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [132.772 221.267 176.713 230.178] /Subtype /Link /A << /S /GoTo /D (section.7) >> >> endobj 91 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [132.772 199.349 191.7 208.261] /Subtype /Link /A << /S /GoTo /D (section.8) >> >> endobj 92 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [186.261 118.182 193.235 130.137] /Subtype /Link /A << /S /GoTo /D (section.7) >> >> endobj 95 0 obj << /D [74 0 R /XYZ 133.768 692.105 null] >> endobj 96 0 obj << /D [74 0 R /XYZ 133.768 667.198 null] >> endobj 100 0 obj << /D [74 0 R /XYZ 133.768 473.419 null] >> endobj 6 0 obj << /D [74 0 R /XYZ 133.768 185.333 null] >> endobj 93 0 obj << /Font << /F15 97 0 R /F16 98 0 R /F26 99 0 R /F27 101 0 R /F8 102 0 R /F28 103 0 R >> /ProcSet [ /PDF /Text ] >> endobj 113 0 obj << /Length 2155 /Filter /FlateDecode >> stream xÚ…XKsã6¾Ï¯Ð%UÔ–EóýÈ^ÖÙ±UI©×Z“Jj’DB7©%@Ëίß~€)Óž‹4~ãE±pëO?l?Ý>øî"µÓÈ‹ÛýÂõ};Ž’E”z¶ë„‹m¾øjyË•ë8Žõåéné%Öú~ùçö§Û‡d´Ï÷;öA¨Ù ŸsÊbeVW~`'1³ˆ:_®ü8±”n¥ÎPîAÒi¹‚iS½M­n€–¤–P¸–Zgä”UÅœLM¬º©ypu¹o*#¨Ù-WadýwéZl°2­l ÀÊzã=>™ÓÚe>—¹4gˆ|…€ò+×µÓиáy ²D‘(8Á‹RKVV á ò².xBFz±ciù¢™ÔÊ:—-pÜà>Ïʺªø›=³—5k¤Ê]%yéÔ–ÇR—Ïd¾¢Í¾u,_Àg³ª"[¦›övWê£ú~`5>/:}Ãs‚‚¿ã(ðÒ±i¥mÛ$Ü ì4¦'FAjeœ…ØÒ‚y(DW¯f­•BK^~Ä•F駬-Oš×ÿpBçñ ~Ýfº¯AÁ =,Nª«`BûÉá¸áJª·šÓß’½„Ž­¦Õ‚} ”Ï»¬;­qêZË\Õ…™“ŽŸPïã°ÂÊS&ª‹¸_—r:¯®[q:”™âU”òô+ÕIG-êuvƒŠ‚ë»ç¶ëŒ3f=uÃ5/";ýk0Jm7Lží> ¼{[¨íC ®FL[R%´C?@º ž$úý@H6ŽýÏ7ºÂÄI­=šŒT}f@ Ok­(zÿbõ~èªÈNõø¯¾<¯­¿wlñhŒ vJr äÞ^Pp¿€àlÅ<ˆ!‘ŠÝj¯¥4y±G·Ôƒ ÄÈj|Q”uMÖ í’ú`Î9µ…¾0¨˜ô¢)3 Ì}‹@¼`Š×7Äãcݾ‰Bãæ(²r¡“à…Ðeºk ÀœûÔ˜W½€Ý™wµXGÇha s2$€ºKÑ2‰õ½‚û«8 ÂÅI{rÐ[O)¦¸·nù± XL„Á÷ƒÈ#Æ¡%)¼™<ðltyˆ¹^h}Q¢—]¤%í‚Lö|hÍÚlc.ßsùŽ¨sFaú {|Gj ü®;¾&f„z!˜7z_ç#‘ñ4_bÛ™+7@šê‚Â`"¼žðÉâA¤J̹LP%+ær£Müï°È´÷YkÌÞðÊLlVL§$1Ãhyô]êJÞ|ÄÀ'ï2Ùr«m'J®ïüáôçRžO9¿Îöö+Csöˆ®`û[js2%ý±Ð¬©@l“Ë·hI•Ëwd@·ÅN³‰›óÍÜf$·nßžEÏÞkÚî[Êïºý^‰ððãæÞ胟ÄqVÂ|ÜöÐÚkq”<íŸboÒ E™z ÀÎlB™¿¤ÓsSæSÑW©%ÚI]rÞ39ÿY*zÕ–ô5#éßçðªmAT¨­fºŽ3-¤¹’³ÇðhL‚7=é¦vâ¤ï×ó˜7Šìоþä’n»â&Ö/ˆò¹‡Öë /ziŽ€ÙsÕ³ ³ñ\•ÀÏûÈ·}7šmÇøžÄçOWÌ çØ£ƒþêBÂ^Ê|'ÕÿÅ”]}Å'Ôå;v¡‰b¬AiáÒ%w9 ¦p¼ð~Šß¿ù·Ì[{ ¤X:8Žsyæãš ¡ߘ1À äpÄáV4 c®>/õ¬Â@Õš§³ >At3\¥‘ë—°*9–µ4òfÀ˜qx”yÓOYÓ˜Ž¸’ -öýÕãå tD®9î´B©sðægºþàò'“’|Í Â\,àBÕhCB±àú(¥D>cNXàÏJ—¯ZHãÀ#Võ ѱ_ÂW(¹§*Àq¹¡ñ eÙžw•îú çj4¦/>Æ–ï¾Ûö¶_™ ËÉdh•Û³mï~ûéÿ £¶¾ endstream endobj 112 0 obj << /Type /Page /Contents 113 0 R /Resources 111 0 R /MediaBox [0 0 612 792] /Parent 104 0 R /Annots [ 105 0 R 106 0 R 107 0 R 108 0 R 109 0 R 110 0 R ] >> endobj 105 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[0 1 1] /Rect [441.282 570.616 478.476 581.464] /Subtype/Link/A<> >> endobj 106 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[0 1 1] /Rect [245.33 534.473 383.311 545.598] /Subtype/Link/A<> >> endobj 107 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[0 1 1] /Rect [338.179 522.242 418.074 534.197] /Subtype/Link/A<> >> endobj 108 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[0 1 1] /Rect [153.628 486.376 237.813 498.331] /Subtype/Link/A<> >> endobj 109 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[0 1 1] /Rect [288.702 474.974 356.641 485.823] /Subtype/Link/A<> >> endobj 110 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [337.639 183.173 344.613 195.128] /Subtype /Link /A << /S /GoTo /D (section.5) >> >> endobj 114 0 obj << /D [112 0 R /XYZ 133.768 692.105 null] >> endobj 10 0 obj << /D [112 0 R /XYZ 133.768 425.092 null] >> endobj 14 0 obj << /D [112 0 R /XYZ 133.768 396.441 null] >> endobj 118 0 obj << /D [112 0 R /XYZ 133.768 376.192 null] >> endobj 119 0 obj << /D [112 0 R /XYZ 133.768 226.746 null] >> endobj 111 0 obj << /Font << /F31 115 0 R /F8 102 0 R /F7 116 0 R /F28 103 0 R /F26 99 0 R /F30 117 0 R /F27 101 0 R >> /ProcSet [ /PDF /Text ] >> endobj 125 0 obj << /Length 2713 /Filter /FlateDecode >> stream xÚ¥YKÛ8¾÷¯Ðeˆñ¡×îi²q72È&ÞØÉf‘ Y¦ÝÂÈ’G’Ói`üV±HÙRkÜÝ›“J$EÖó«*Ê÷vžïÝ\½Z]½¼–ÜKXŠÐ[m=.%‹ÂØ Á¸x«÷e"¦3îûþäãòשˆ'7óéï«ß^^ÇgßI³H¦æ‰ ®|{Š{¾¼çŸÌì73©Xч‡ºÚ3]÷¾ïŸ¤B åNZ¦3`IgùWŸ+ÝLg*&íí”O4ч¢j-UWfñæ³È4Ñ5›Îâ$ž\Oc9©j\§&‹©ˆ&UÓ.³:?ÀRûyulÇöÅt 'ä0ckÚ:/wDç òîÍg ¼‡g`õx(ÒLo¦ ¸œä%>l¤I›=Ý ‹¢Ð ùË/×UýPç"a*n‘‘¿Ø°êú*ç\1ìÌ8 ËÖ÷\ߪºý¥Kn$1„Õ¸°3ÙOîðÐjÝ‚Æ#OV´ZÐén’†²´¤¶Æ$@èéþPØý×t:½TëÙ_+¼MóÒ(\E“»¼ÂP)=²´(ˆj«@°yWÜèöMÙꮿõÿæí·Ooæÿ^¼ÿ°B—ð;-Â$h+Kteä+«[ðb©vRD!ã<英;îu‰‘גϘ¯Ð‡veUwµ¥ç¸Cq?b*ˆ7oÅbùíãrþí?|˜¿[uÂŒ°.a¿¬m^•öȆøit{ÙíDÄY9· i'0î>½ät2d2¼àtNZCPt?´ó šÈPq·U£mÀ¥ûªÜýí‘(]EÖ¥âs-–O’Õg€:ÝÓø]nü¨Î¡Ïa|;jiŽ»¬kËÅŒ,Qç¼Ï/2æ}æEuÌ‹0î˜Çqb©Žy\‚Ìãà¼ÌÒCs,ÒÝG†âà꧈cùz(ÎâõõóÄùi[Ômº.ìÌkJ%Ù 2!¨ÉÏHµš~žTAtRah%ÁÑN|Iéñ–Â;òB– 2ÄÌç܃­• }ŠÉ8„ˆ8-2Há,ŽseÁj~6~6ü™ÀØ-4±šU¤:i“>(eqOT{k—µúGKàÈÉB_öÁ‘’¯E¢j{ʪ† \„‚v¶e±2c¨j„6ß«wn®¼/f‘`¢g “dnp4j¼C4¹êFÓr„—Lø”~åRåeV7zW§‡Û"¡-vfÕ~Ÿ–ZANhR!¼¢©ƒ`b·¤±Ní@ߦÈñ÷n=)ˆ&Ý[j\voi3"‹ß·Â6/苇žÃY¬ä)ó«¼ï“jÐÈcs+/RA†,€Ì2Ó…ÕòÓÍ3±2º +ªÿðµƒ? -ü©ä þàÅÀL/¡¶ ¬ÀÑOX\‚Ãa1ƒ³7ÎØföç@ðæé ˆ0ÿa³h;àJ S±Ì¤/,Núü„“0Øá$Ð'Z›’MÓ‹ÁIxpFÞ¦+„Dý™"XúŒË°ï:'u<+ÅýüÜ\.`hΗO¬%¬Xq?>1QbºØU5”ûÿ¿¬ðY’„cUÅ»÷ß–¶ôú ö#±Ò ˜1oóim'K‡|¨½±|Ô0 »u§œhÞl)¦Twºõ‡¤ õ}Õ·®q [årt ôwv̵÷8eðÁ&µ+|½Õz³Nòÿ ‘õl(M'§dâjjüÖ>\fù)QsSzÀX‹K ¢W³M¾7¼•Ôè/Q•©Eú&Ó¥n©{ÉÔ·¼Hoþ¹x;Ìì‰dqõ ¬44»pfG‚¬m³ Ôm|_ÛÊ>ou^¹Në{ÄvP¦'Q2P ©V«Z,ÜLƒ6(þ¢‡Š¶5žÍ©ƒCº½­µ¾¤`SnÓàµ/Ç-vw«m7¢Ö€²ðMÓo“l ÀŠú˜åiñ ››ìÕrñh˜Æªa*øÃ0eRø D˜F“Åèž)=^å%ˆèå!Í4}lp6­ÛÜ1"B&ⸯD|àÚâ;ÃÚMœØþÛEcŠ§ÒÍQ­`¯Ã$,8@ò*|nëêaʆ®4’ÀãUž™Õõ¬Èÿ0;ŽÙ³ÃYà3<Åsþp[‹ ѧ*^ŽÄX’gЖ[šCG5Ï,;ÖÐкZ—B9:ÞŽF pÖÔ{ó´ulÂPk )ôÂxÙkøêÞå~,®|[yã Ùf,lIk,2ióùù›îšKí5gArºЭ¤]Q­¬Â]=á¨Ý³žPýlчٚHTʧE›„:}NÀ„ïñ8yÚF™-zò…ñàjm/ Li. LwByéuN9'oºžªùÁ"rmèûVÁ÷{¥Ò«*Æ®y c¨0qJúïÃ,0qºÌAë÷k–ùêêO[žóî20 yÙþêËï¾·IðqåÝ™¥{X1ãedá-¯þE7Ë`[Q¼ÈDÖ”bÐBòŠó88+ëa]äE°šÓiò€cGsyŽ£Âì 1>•PšÓ@ÓêCcçÌ´=“6Ða4¥‡m{ûü@ßË¡ãL†ý¾wÀŽolzZE¯b‘Z,r=ÊÜ{gƒŸ‰ë—@Y/N1«€,é"0Λ¾]à$‘€þâîvŠÈê,ç:‘ g$¨¾ó+3Ùç^_á:E^h¶c¤)ÎÔÂC°¿ê Û?vhFô'¡ý“]áí®±{{%,q§Ívl+¨†Nÿ¹eR)ReEŒ›+3boDÂA«X ÑE«PL€•f ŒÍóÝÕi_TðÈdpsJWicüuõbd+Œ€°¿Ó|t+å³@©G´vª {7b·²—®.W «9ˆòCçœ6Œœ©’þ©Ð¼¬æŸW#' ƒ‹ã¿¼ZrŸE‘ì{µxÄ«•ïÛ¿ ЪŽÅv(°€1Ë/GvL‘͇‘­Æ#ÛlzÛȉ‰ó7iDcB‚ö£žsƒs>ÁyfŠ ë¯FÌqƒ(É8ø¦½BJË™H’¡ ÿ¦"À#l¾슷÷6NÇÅÐJõi0Ú Ž)¼\iç zTˆÇ$ç{Ÿî“úš‚4›tQ”Öôw¹%$usúŠ‚Ê\ž~æˆCóJïòr‘b 8vJ0Žk+ð‰8‚´ö½õ?ÓÚEØççlj-plKϬ:Ö&»º‹9 b ˆÑ%|°¯ü™õTO6 »›€8vP€£ÀbMdw§ˆ/äCÃI=Ì2f‹ÚêOânÐó @-Ó_J¼<é',¼Ø?~ ï0éi*£>€V¯ì¯C!M½Ï|Ÿî 5"8ôÛb~C”;cñÎtá °d€ŽtCô±Ñ´€"c³3’ºO*$âËF Æ ‰îþœ.РΒaÜK[®¤p×ÞXu¡Ó‹‚ `~"žŠFƒKÛáíëYÉø?—óš endstream endobj 124 0 obj << /Type /Page /Contents 125 0 R /Resources 123 0 R /MediaBox [0 0 612 792] /Parent 104 0 R /Annots [ 120 0 R 121 0 R ] >> endobj 120 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [311.563 496.339 326.286 508.294] /Subtype /Link /A << /S /GoTo /D (subsection.2.2) >> >> endobj 121 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [224.207 474.919 230.669 485.021] /Subtype /Link /A << /S /GoTo /D (Hfootnote.1) >> >> endobj 126 0 obj << /D [124 0 R /XYZ 133.768 692.105 null] >> endobj 128 0 obj << /D [124 0 R /XYZ 149.011 206.237 null] >> endobj 130 0 obj << /D [124 0 R /XYZ 133.768 193.064 null] >> endobj 132 0 obj << /D [124 0 R /XYZ 133.768 172.308 null] >> endobj 123 0 obj << /Font << /F31 115 0 R /F8 102 0 R /F28 103 0 R /F7 116 0 R /F18 127 0 R /F17 129 0 R /F32 131 0 R >> /ProcSet [ /PDF /Text ] >> endobj 136 0 obj << /Length 2546 /Filter /FlateDecode >> stream xÚ]wÚ¸ò½¿‚³O朢X–?ï[’’4÷ÒÀ ¤ÛÝíŽ1 øÔØÙÞ4ýõwF# ”tó‚äÑHÍ÷ voÕ³{·ï®fï.nïE,ò¿7{êq!Xà‡=?r·½ÞlÙûËrúnÛ¶õ8½ì;¡u;ìÿ=ûïÅM¸·OˆÕ\Dxg›[šñâÆÙß2\°Ð0qYÐÎÛ‘3™ÎïÇ÷ÃÎÝ˼€9¡×\v_ôB«ØVi‘³ƒ}Ý+ÍÎ÷Xäîßøááò÷ùÕåõÿnÆ÷Î\Î9PËÃæöÙZÒõ‹8é;õm¥Š:_ìIųœ–8ºÖ²Ï-#æsnVÌXÑI®µÍŠêü3Žß1½û4 磻ûá||s3ÎÎ=EØ̳£æ)—ý:V¹‰³ §Ü*¾Ú\”²¢|Žñr)—„€´#HÓŽ€ƒE›¤2 Þ„Ú!ó"Ž¤³È3zE÷ØÍv[XYšË’`úhÙ3ËÄ™ï9ÀwkŠlaF Œ>Ët³ÍR ÃÕtÂÂ?¨·R•  „R<ínÖÊÜa°ã{À·a ±–Ò,u2þ¸ßŽÏoîF£cá¶ÃÜÝ¡Ouž ÂÆYZ!u/ |Ûµ¾Úž<Á#]áY¥Ô(Z„6Ú=µêÑäáö]ï/Ø!´uZ ¸áuD WÀYü=Ëmk[WUš¯èÍwœ˜×£xˆ6z•OaÏ×ìžgtJæK©½N7ñÊ,”YºZã{ªìÅ,æ´ò¤à%¸ptdª'UgÞö€[”ikÔðªÓgk»§…ˆöT›/Ú)ÕS¡6ã`ôBÑ’€ÿq©Y£QŠ¬®P³Š8繞%ÙŠÑ8P³ò´’ƒSdÉLn$>ÈÒoH™qY®eyÞ²8é'†=ÞŸ3f?`Û:ÅKmZ|Ï|¸& A•ôõ¬Òª’hܱFqA_H`m.Üø&H¥ ++%ã éë'¬[™w—õv«àj¹üoçû¿Ngó‡ñøÜûCÁ\áwܲVRä@hMvR<«åj:1% HkâBLÙ¤?PÏl¸¤Ÿìsæij÷žœàúºhT•Êƽ9À e–*‚o^¥äœJBÉd¼Üm,hp¬Mš§­ì Õ -j]«7ø»0ªO øPÜT‚3¬Þªw÷ãùløåã‡EßQ<Ÿ‡D³Ï«’ß+ ài%}hõÐÐz A AGV"¯q¸‹Mç$à[]#ö{œÙÞûI#Ñw‚ݶC*|„|ª3o nT02׉‰ÁUÖ׆ˆ±ªLªñDcLƒqöAÏNˆPG°0 z³]§ ¯G!Áe"ôù;$Íè„á!œ»æiÃ=øø ðzÆàs~ZÀ“»/Ÿ.'¿l[ZÄ䃚I8Ù¦ß7ñ¶¤-Xœììž¾I¢ûí”ß•è›Twtyÿaz}9þ;¯!<[3”fZs¼–R‚å4fq¾,“؃§Rãýcr9´¡¬À® ÆÓψ‰zªRqZ½Ýb'S1Ÿ~¼üpw{.ý³#æ…m&‹™‡q˜MúÚ…UÓD¥ÛŠ`È´‘æ3Ï^0à/ÌÂq à os²M¼”fƒyx0ÿ VœNÃxÀDÔ¦§åú)Í;.=\`@ø ^>•\lFŸ‡|»ñ–qU( ñàtµÓ>A‰zòK„´X2_ÇyB T¸Ë´×f~x æ¨n&=ã6y®pÓ„‹5-”ëXgÞ¸x;¶À¨PÑ<‰sšd¤x°];<½µX@’Rôy-óSyLBٚɜ‰:bà!ƒ“˜e:‚aì$õ/hiòᦃƒÞÙ‰¬)FZÄŽ³Ò`RýVžJÇ=—ÙAÐp6W§’kæ¶füþÄ x+›FÆG'ð_?bq|>ƒ¹0ï0Òå¬@¶<¿Ý¨¯ |Å¢#¡ƒŽ!ñ*ƒ$´Êw´yƒ[ÉKc2OŒéâŠvq¾°–i/2J¹µ¤E¨ªb%AÕîeRßAôQ÷½«X-AÐå~¨Ü ¨I­”ñ§ ͶYä»Ê‹ž}"tzŒû­4 uê,‡9‡EÜONómz­)Áw×%2èi¹„ø§Ä5¾¾=Nï $¼~¤Zð×|0¥í®IN]7°Ö)TÛ9MtÈ^Vh'¤ƒ-â)¹)vöº$ EÜæ¼#çk¼…¶÷MB§“&o*ë0ÔJ  /„…_fí7.JÈ”» R»Ô†O!Œ'x£!ôªÅó¿|fV4éA, ņDÔ<èF_Hõ›µ¦£Q¦‹Ìp‚1ûÞ±£‡0Z ¡^6µL·_õuœz£9]?M†Óé¹ú.7ÚM‘]àGcÑ.pÕ´4\ç}0&ÅFgÿK°òkÝôCaé¸np)ô¨éz>sƒô¸Š¿õMªí©ºÑ˜hùÛÀm-FZÊ%©Iz‚䤚ï4œjµ:;"Ÿy»øòñòópþçèîê„i›ˆsyƒ¯Íqÿ$8èÏS郱‹î›Ú‚ ꆶ34†­—YJÝ¿’Ë÷˜–{ÆR#Žý¾o4#Õ‚‰ü.“ºŠIaáÛá>Ê,]Ä"ÉÎA2‹*V/ã÷l£hvc/“&G +|&ì6*®«jûŸ‹‹ççg¶ú‘nY¡VxíÅ+î+ð¢½â†‚9çƒÄt ` áé²Á BÒÓ °¦ŸÑ¤oé£MucÏEáqŒjã!jÃzU«œpC«a?‘}ëV%öã„ÝZ’Þ ß_¹pÑ©¸‚뎷À$¾Èäo(P¯õq8)½D(jºl\J‚½V¡à¨äªÎbuŠž£¬$üq"{ÇüØ•ïPî´êƒhÔÑ ”@P–¬µo€^ð®¹ë"â„×mïaãBC¯½”ªïÐ4`aYä’ ÈÁŒŠ«³šß¬«_Ä”1uòè ÿÑÙ†ÎkB÷¨úâdø‡\k\uœ$…Zb9H.ܘѾÇ¿Zü$M@Ðe“vî& $úÿŒ$>þ«‡³wÿZlõ endstream endobj 135 0 obj << /Type /Page /Contents 136 0 R /Resources 134 0 R /MediaBox [0 0 612 792] /Parent 104 0 R /Annots [ 122 0 R 133 0 R ] >> endobj 122 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [391.515 597.958 406.237 609.913] /Subtype /Link /A << /S /GoTo /D (subsection.2.5) >> >> endobj 133 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[0 1 1] /Rect [215.905 183.512 348.656 195.467] /Subtype/Link/A<> >> endobj 137 0 obj << /D [135 0 R /XYZ 133.768 692.105 null] >> endobj 134 0 obj << /Font << /F31 115 0 R /F8 102 0 R /F28 103 0 R /F7 116 0 R >> /ProcSet [ /PDF /Text ] >> endobj 140 0 obj << /Length 1943 /Filter /FlateDecode >> stream xÚÝYÝoã6ß¿Â2°æŠ"©.úÍ:izA²ˆ³mÑë!mÚN– IÎ^ö¯ï ‡’,‡°Óîå^,ŠÙßüf8”ýÑzä®ß}z|÷áJðQÂ’0G«‚Ea< “€q_—£zÁxÂ}ß÷¾Î.ÆAì]OÇÿzüùÃU|°Nˆ˜E„š '¼óí.íóÃUp¸db×L„dqD e^VÛr©†[©€ùJµ[Ívã è¤Ù>—ºƒXá5M #›ÒÛ–fæRÿ@ê”á<`R$­ÔëÛ§‡ëO;¡)d; D;D,ðå¤ËûÛû‡§›»ÏÓß^ Œ ‚Îvd÷° NX¬¢Ñ„Cg  «³ïÿd¼… F´¤W®Ž†È=鎆³•Ëz¥X¨‚v¯C”òO:œ²Ú! ÌåñÿI!}–Hé@²IçùI(#ÄÝ.—eѤY0Ê$!¬°Ñc…on¬x»‡oÁ (ƒ“XqÎÂ0ü»`MÉ½Ç IF¦™™ÆY¢ñ!ïCdmÇAäí릳—n¾`¾ØÙ2ö'DÏ ë­&¹5Å°a$Æ7v¾X;6Œ$Ô{0‚/³j=O_o(#æ÷yëLø%ðfiBZR´) ØËdÈ[©ï] 2ßï&ë¿-£ãD1?AZ®˜ìéó‡¯ü•ÉŠ2ô¾ ’eÝÌU¶CgJå¥Å’g¿˜|O/å¾Ùí팲È_@ §‘6 ª2¯©‡24ÌÀ~‹¿sò–Ý×x$A Ri3±´=Ã!éêMºÔ Ž¾Q¼ÞÏ'¸sSei±Î1{© "¶“š’žénW•¸ï²mÚhÛIÚœ‘W6› àÞf̽~ŸV¶¡ 6P•¸Ç“ÿDªŒ:A@$CßÂõÃú0²LwûD©Eª£¤o`»éCü^;<€“2êã¨Þ¬²ÝÝ?}™‰§ÙOŸoî®_ÆýˆÅ’÷–5YYXSθZ‚P¡ôjÝ0"« 0ÉiêN«õ¾O/®¤åwÁU¹”9ŸŠ)!Žc| ²bF (Fñ0ÊRºuw¸¯^ÈΆ ‹±¡&uÏo5²¿¢q I\ðá8Çàsä\ÝÞÿz þ˜~8ÐVªþni?Táut8¤Ð6Ç{"c Øok[ÜöÖZ: pÌ#]ÿ†x ûB¥½i ŽŸS#×M @Îá¶ÐE¹_o>¾ý|`úõîæîæñæâöæ÷éçSß|Ȩ*>@ÖuýaýW̳DN’ïSPÇIou'{Ýu{)qBWžÍ±¶J«zo—TLG‘ÙÏX—ÊX oM–æ@€%AˆÇŒfkfyê2´äýåñ¯„f{€¶áöú‚+Ɇ1ã!3gãðP:C€$†œ–¸ðÿ”a_ý0}|÷'6Ò endstream endobj 139 0 obj << /Type /Page /Contents 140 0 R /Resources 138 0 R /MediaBox [0 0 612 792] /Parent 104 0 R >> endobj 141 0 obj << /D [139 0 R /XYZ 133.768 692.105 null] >> endobj 143 0 obj << /D [139 0 R /XYZ 133.768 390.299 null] >> endobj 138 0 obj << /Font << /F31 115 0 R /F8 102 0 R /F28 103 0 R /F27 101 0 R /F11 142 0 R /F7 116 0 R >> /ProcSet [ /PDF /Text ] >> endobj 147 0 obj << /Length 2292 /Filter /FlateDecode >> stream xÚ­YYsÛ8~÷¯à#5c"¸ ÎÛ8‰½»åªdmÍÖÔ5EK´ÌZŠôT<ÞÊßn¼$Jv’yºÝú€h° hpuv±<{s)XDs,ï&‰µ t £*X®ƒ_C¾ˆ¥4üéöÇ7áÕûÅï˽¹4£}B `j7h\pF½”7—°†1’(ÅqmäGB{„;¦‚Ž— J´PÛMÁ›eöWë–N¹ª„ź¥i¹žãÇh|ÈïÃcÇ2)bL <#fˆ0I¯)a`¦hxû¸ˆ³Uþer•¶yUNŽ>2ÁØZtÊòê:/ÛE¤¸Tú*ê¦VUÙxêê!­Ý×wM[çåæüÔ’ûªlËt›£J1$aÖЂqq“ÿ/s#Îì®h²M×Lø·«Ì¨$šÆG…w:{–#JZ䛲Ÿ¾/ª´#”›bïŒ^ï¤XL¢¯sïõwY³ªóGëìHiÁ"LëÍn›• ÀDÛxÞ'ü¾‡çñJňfÉš'Ü8%*1ÇÁ<^«c"ú˨…kœÕÛ¬"•ÛÊýæåªØ­3Äaêi¨ŸýrþsļôÔ‡Ì}T»öq×:Ì0‘Å÷ü»³tKÀöŒ‡KÜ&” °iØÖ ZÖ•hüoÙdu›­ÝˆZ·S‡«]]ƒ©á ­›¨Ó¦Íj÷'ŒÃªÉ½“` ÑÙd~íî{vßUé9V÷ƒˆyߎ³)n¬¼U3cmF˜Ñ¹?x{—W× @ƒêÕv .mh)Ëìi§uæ–´öÀ:ööǹ§¼(ÜÜc覛Ê[ éjUÕk4¥u„×crçÑ×BoH!÷ ”Þ@Ü7$LUeñ¼ÔƒæR*ïJ1€5n)ç‡ýT°gSª±¸‡ˆW}´a’e4Zvv½õvuÑ7k&çá@¸vÖÿ¦¬ªä”‚‘—1˜ãÞ‚]:¡¨ÔÄðSŠæ5<üˆzTM{k£Š#Zþ–jQ 3©~Zàe(òµ›]"jž—üæ( %Òì•<ëOƒz¸Ô74Ibal(ŒÄ‰ D.â:‘:ã «Æ&0äþtiãÔ)+‡E® €‘MoQÙÊï¾ò¨»vWj¬¡”„ÅIÀ •ÜíýñðÞIˆ­÷Ñ¢¥®ˆ‚*æ™ô‚ß÷ó2Mÿì¡l:(òñêÒ͸ðv+F%™ÇŠ°bÓê7`e|Y]Š¶ÝÃ;@ƒs1Æß/ãÑ_ÕõÚ^è´èîéf!x‹Áx|ƒKc!æ|p/¤M¨ék®—B(Ì!U©©æ6ŸŸ èD_~b¨·X’Œâ튇Û5äÉÀb âØ7L˜Ú*e&sß?í$FX[XÊ!"pÖ%^Xìó3L á3ˆ µŸ^6kÄmê•VRÚ÷UgM'ÇÓ0RÚ_”¤4$ „âÄ勸c‚Ù;EšK¸Ô±òiƒ`Ý$’ð? ,‘lèÂm+Ôã¡ÊW™Í û Sá òb—åêš¼ýcùþçåogkÇcP¬üá³:Zù#d5Zú|FT ˜RÉœ¨ëCY1'’“Ud÷í1)ñÈ)>`š˜H¾çC§ÀÍ 2¡‰>¢@oì÷1-´"1ã3g½˜5+—f,É•#UÛVÛhzÔ®šÄjÎ…3v…´AIŸ5ô¼ÌξsæMˆ006cØB^“ÇNö²“q ÉZÎQ> Xmõø ãE\K–{=Ñ kœJë­æªýÙ„Å\Ìé戹/fb6†I—ˆPê:»Ow…o8MÈ~°³0Ya²mƒ-z!GùbþP{É¡ìÈëÁ%”ˆ¤×<ŸkÝ%”™W¢®H2ð#¯y€t9Õ· në÷Q}ïÚÕ¯þ¬ºÏjº š‹ºŸýR÷3Œ˜Šûág?¬¦ÃÏçpFµo:ê‹ÆrÙ°>‘ù5òÁA”†zÝÇ…§\t”‹Ž²ô”eGqw¥w<”fª•=O»‡‰/®p„Löú‡slbùl…# +W¯¨pâo¬pP)WBKãKh˜é*œ*¤ÌÔ¼ÈÁ-­«6õͧeëÍ%Žr÷eì/ßAŒªâ® “.ÐæÇj7TEeUXaMð_0O`ò>Òœ»myé~×Ù¦Î2ß¿}ö~yö§o¶Xÿ–Ê)Tø»VÛ³_§Áˆnˆ8&x²K·°r½Á\·gÿv³n qìâ4@PzrJ gjÔ¢Áº8€xC¤³þcøb ‘‰QÕO4ØS6þµæÕð|Ãd÷ÆŽKëµ#Cw™¸î2 »…î› Am›€Cûna?šŽ^€IaÅSóƒˆå#-¹ÀpÚçÊešE‹Hóð¦Ú¦åܹbBã>¤žÏðÔÐ^Æ3/ªb=ÇLt’à©j­øþ³…ä´šá  49ÅZœ¡{ÚSõ([m îR/²íóÝ?²âSÖæ«t†—€^|(W¿€×I“B±…hýZ®îŠüÏ]6ëë8y½³äQ­Ë0°‘éÓSƒ[ßV»:ÏêF«ilÜG0v„›]Z§.îf®øMü{¦±OÂ6Hã E–Ÿ òe^xé0Ý­õÉÑ„Ÿòì Ù¹×^Ø÷ø±'õM»ÔqøSãs&­¢ÏnP¿©Knô”h¡Âê¬ÁòÞ~»ä‰Êùânäú²*#—fªÚ›K2û2šŒ_FqνëíÝ¥ûÀš¡ÈìÃŽÏ?0i t÷¹®œi<¥¬<£áÏô‡ÃÁp"»üwÛèÛf|ï­¾ÌQ²ÿÏc®þ• ÿ¼O; endstream endobj 146 0 obj << /Type /Page /Contents 147 0 R /Resources 145 0 R /MediaBox [0 0 612 792] /Parent 104 0 R /Annots [ 144 0 R ] >> endobj 144 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [411.391 459.664 417.853 471.703] /Subtype /Link /A << /S /GoTo /D (Hfootnote.2) >> >> endobj 148 0 obj << /D [146 0 R /XYZ 133.768 692.105 null] >> endobj 18 0 obj << /D [146 0 R /XYZ 133.768 667.198 null] >> endobj 149 0 obj << /D [146 0 R /XYZ 133.768 648.144 null] >> endobj 150 0 obj << /D [146 0 R /XYZ 133.768 568.436 null] >> endobj 151 0 obj << /D [146 0 R /XYZ 149.011 206.866 null] >> endobj 145 0 obj << /Font << /F31 115 0 R /F8 102 0 R /F26 99 0 R /F30 117 0 R /F27 101 0 R /F28 103 0 R /F7 116 0 R /F18 127 0 R /F17 129 0 R /F32 131 0 R >> /ProcSet [ /PDF /Text ] >> endobj 155 0 obj << /Length 1682 /Filter /FlateDecode >> stream xÚ¥XMsâ8½çWp4[Aч-Û³§d’°Ù¢’T sØ­)¸lÊ!Ù_¿-µllp˜™š²Ôjµ^w¿nA{‹í Ï®&g·‚õbK.{“y ABõdÌ £Ao2ëýíñþ€QJ½çñeŸGÞð¦ÿÏäÏ‹Û¨±Oˆˆ„”Ú ¡8£î”‹[6DNv |…SX@½'¥·EÖˆHx¯})¼dµUx"oI{Ũb±â›r¢Þô±q%"ö+ã’lÖ¡ÅD„¼’©•=l:ôIIhT²…µ÷Óá•›L$  `’;X‡#þ8þö|w7¹»Ýýus} ¤e õ‰¢êÔtÞq‰˜€ÿ*‰Ri¶èp•OBZß4-»À „²ú¨ûçÑèX ÷ ÷ëÃò&„1 ~}O/ûÌS8^¥/ER¼;³\ãjš¥:MVéjöûi #NüÀwÊ&†7OOO'°“œ,h@gMH2´@Ee~Þ@€O§Û¢øž9Ng‡GÇÏŸ?ߌÇ'ì 9‰CYc§—ªØ¥¥"βljƒ€Ûƒœð€‡$Š¢*_Ê Ú””H´‚øºHvé›ZU~n§"n°‰ת s©8Þ,ÜSÓô+eþ4Ñižµ®õ8©9¥x;àÁ¡M_i@qa8*!RüØ¥3½<ïXXªt±ÔçƆã”ð8‚£,GG½åEº¨•ÔÓï8m4Ðý*Û®QjžëD×»÷ ú}£Ú»]$Nó¬tG¼æé G¿mzû—e]N¨/Â$â`ïîÜp­Êi‘n,ú@‹¾¥0ËI±Ø®UÖ'éòcŽŒODS§±÷x}‹â†ŒÔø‹­}ø‘oõf«IÉÀ›ô#ËfáÀ:« )»Bm‘Må¡Snì`)…2¥f%uŽ¿î Ü7Í×›t…§JÈ!ààcgq!‰ÏküqùåæÛèîêñ~Øá,(ËaÜ øŽJ!ˆäµòúD0aXjÝ÷ôq”„•¦™2Œ“©™‰Î\ij½&\úMM·:yY¹o V“‚æ«Æ|¬Òìß¾sˆù¶Ð´µƒœ,+{kQë–°y{…¡?3x:â@ÍMMÅK­7Ÿ..v»6Ù‚äÅâd±I$j4 s4)ŽlÖ¢ž‰½EÌë7cònXºß¬T…¶(ÄÀguµÛV½ÌåVŠ¤ÔªÀ1&d^¦Ž…`Ê`Q*'ûbö½ã8ÏœÆ|ŽF3ŸÄ¾ßF²›KXHdØà’'kÂcÞE%ŒY7)Ž1²áÈPc`²a QS"vƒ Ž½+µ3V&…B½´Ø‘Bf­P‹LZ­p´&ø(s ¡½W*B<™Nóbf:¯Ï9f*w(û\X Ã=f `jÊxÂLTžèT`_½‚{†Œa<˜ùª<€¼îä€âdã âÄ™k;l]>¶‚5бs vÊ5~5 vPÝ<(”̳ÙÔžÏD¬7ÈÉ6ÌÙjðK8e'” ùcvúžëdÁÖŲJ!õÈX<·ÕÁÚ6¥£-à’° nÓÏ;r%$”Ö©ò^©ùI×Ì!gý r±ƒUnãË5{vÊÆgSÆœ•ºÅê·^t8 "`ÓÉñŽÐ=9 óä:ÈžµJÊma(ŠCÂ΋|#«Ý À<0|gBÚ$„Rs#ȼ¬š5F·vZ»L9¡®8ÚÙbïUóiëŒl7øûbÑ@ÿg ‹®4ª¶Á’¯}ÇÉ›*OG¼¦b¶Ã{Ð_c.]xréWÚì¤ÅFúÕ"ØmÚ5œ›%:!]Ì,}âGѾÔ{^u¾.) ¿óÖŽ€äe[Óe‡ª˜ð} ´¬FcBš±%>l%<äAyíÒþ}àzHàfµÁ(\> endobj 152 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[0 1 1] /Rect [136.646 382.945 248.476 394.9] /Subtype/Link/A<> >> endobj 156 0 obj << /D [154 0 R /XYZ 133.768 692.105 null] >> endobj 157 0 obj << /D [154 0 R /XYZ 133.768 667.198 null] >> endobj 22 0 obj << /D [154 0 R /XYZ 133.768 564.182 null] >> endobj 158 0 obj << /D [154 0 R /XYZ 133.768 542.091 null] >> endobj 159 0 obj << /D [154 0 R /XYZ 133.768 462.383 null] >> endobj 153 0 obj << /Font << /F31 115 0 R /F8 102 0 R /F27 101 0 R /F28 103 0 R /F26 99 0 R /F30 117 0 R >> /ProcSet [ /PDF /Text ] >> endobj 164 0 obj << /Length 1039 /Filter /FlateDecode >> stream xÚíWMÛ6½ûWè(—Ÿ¢Ôœ’¬×pal¶÷Ò¤(´2×&`K†$gÛþúEJ–l­›IN9I“ofß ÇØÛxØ›ŽÞ¯F7wŒx1ŠCz«g0†dyaLÁÂ[­½>cì?.ßiäO'ãßW¿ÜÜE}ŒEH2­7DfÁ;/7wTv–nmÀ8Š¤ó€bà…ì/Tu,²qÀ"æ‡ÌOvGe=Ò®Kì$B,Š-ÄfGåm‘¼<è?Õ®¼ 1"HÊ° ±¨½”?ŸGÚݸ-udLçôaùÇãýì~¶š½›Ï~›Üžat!戉¨ñªŸ‰°Þ¬8¼=%1mqÊ‚&­«ûÇùü†rDyë,/€fÆLXðä~µUÖ°ÓOERüå~-í3Ë+»LgºÒÉNÿ­Öo¯òG"Š¸àŽÀ°Kàd±øuq…¸"AD‡·:„$³¨¢hbÏÇh2MEñoá8Ìã\>~ø0Y.¯Ä#)ŠOêÉ©âE— ¹s=BP,­¹Å•(Š¢FâÜ®e¸»–a²6ÏZÄ˃J^‡Ü/»º~Üâ"âJgyN¨Û?aÂÓ¤ÒyÖËéfÎJi:×µ ¢Ð',°µv<çÅ>©~²iž•Îžn“¾½)+÷d +ðNŠâð”u ݪ2-ô¡Î¬mgHŠÍq¯²1¤[•_ØzÄöÄ&íájE©b¯9à‚øUnžØÏÕáXY›‘bý,žte‹Å|¦ù~_i> s=&~¶±Ÿ:ëouphÓ†XiØ@`»JöNæ®Dû¹ÑŸM+V®ì) €åÜ_5UÜpD¥áÈ™ÔÕ–gÎ" N´÷JY°±7Ì-uVÊøÄMWÁ¢¥Ïrm®kŒ/[š´¶ÖÞn, ®ôíéY 0kh­wé³>Y÷Ö|€¬Rkd9n¹}ŽgÀ+—Ìúâ’·¤c¤y7ê/ûù­í//ºÚµc8Rõ*û½Úèì!Ù¨K J†(mû€©'ù¥rA-UÚÖ2EØ+6ž}YLGÞÇ:¸±{'8MÅÁ©rhX¸ä]©­móTýÏ|H:5ªJKbĸl= äLr§t ¬»^ø©HŒu›´î]sr$Œ®ß-4„^xv9›VóºX)PpRÄzŠ‘fîÅÜÚZI¡¡æìà/šÙ×l^o]!‘øOSÛò¦šVî\ÎPb˜W¾ýH ØÉîkM5@  Ù©¦Ö·ø©f’%O;5 ¸D´‹M_@„¢ŠÃ>â­.;²ßà/†8”Ä·”lŽƒsÒ>_«þtáëüò=Gwùþ_øÉjô™Pr… endstream endobj 163 0 obj << /Type /Page /Contents 164 0 R /Resources 162 0 R /MediaBox [0 0 612 792] /Parent 160 0 R /Annots [ 161 0 R ] >> endobj 161 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [459.879 420.803 474.601 432.758] /Subtype /Link /A << /S /GoTo /D (subsection.2.1) >> >> endobj 165 0 obj << /D [163 0 R /XYZ 133.768 692.105 null] >> endobj 166 0 obj << /D [163 0 R /XYZ 133.768 667.198 null] >> endobj 26 0 obj << /D [163 0 R /XYZ 133.768 564.182 null] >> endobj 167 0 obj << /D [163 0 R /XYZ 133.768 542.091 null] >> endobj 168 0 obj << /D [163 0 R /XYZ 133.768 498.248 null] >> endobj 169 0 obj << /D [163 0 R /XYZ 133.768 376.531 null] >> endobj 30 0 obj << /D [163 0 R /XYZ 133.768 273.46 null] >> endobj 170 0 obj << /D [163 0 R /XYZ 133.768 251.369 null] >> endobj 162 0 obj << /Font << /F31 115 0 R /F8 102 0 R /F27 101 0 R /F28 103 0 R /F26 99 0 R /F30 117 0 R >> /ProcSet [ /PDF /Text ] >> endobj 173 0 obj << /Length 1582 /Filter /FlateDecode >> stream xÚÝWßoâ8~ï_Ác¯ÿJöžv·õ„JU¨V{·§*C£ƒ%¡UﯿÛvO·/÷qœ™Ï3ß73¦E‡vŸ'®8ëÄ$V¡êLæÆ9Ñ*ê¨8$ŒÊÎdÖù#»=F) îÇŸºa úÝ?'¿}¸Šö¾ã<"šƒQûAŒ.¨÷òá*Ô{[{~o iïH‚^˜¤Á¥)§Eº®Ò<ëöx$‚$›á$Åb³2Y—‡AU: á>Ú鱈ð(vFËp]ö³äqiŽ+F8Àò€Ñű=“Hˆz5w™–'ì)"åÖÞÌ,ÓUZ!lŒÖÝ^¨“ †naš¯Và±tOUî~_žÒ)†÷É=&øCƒ%¼…Åi²lØcB K9KŸ®U>k Šm†RtÎ!¤ëõ253Òí !ƒÉ“){±r~g¦ÞX˜‡Ym@ñö1‘—Á0¼? ¯oúãÉõíí°`bßB&=Àþ c±Y&•E xP=™–(Jâ¸þh0ÉÆ¥'Í\fæ›jSøF\˜¥IJS’ZÓç:pLõ9Á~Ýß\~ºûvN­  *¶ì&÷dIWPmpø‚I¦²%_-Å+âƒÞ˜òjC=¨vzîvÎã~λ3pÈÌMvÏ]ÅùONuïê(‰vT<9Ôq¾{¨Ãè÷ðù)ˆ E Eaù$"Šö“ps}s=¹þ4¼þ½ŽäŒ Âå–‡éÜÅÚµo É2},,í^=iü„–mS•Á ´ýÛÌ~=Ö{jaLÿînt÷n%Ö“ÌA2Eí?n|µåî 8Þf šñý—/ýñø ’X«OÁ*^ÒÒÔÌT'»Ð:ò›¡®DÍLåÛ9ÝßË¡ŸðæTp›§Y5†è¶Ù††­;b`Ó(("VM£ØÒ¿¦³mAÖ‡S~V·L˜—Òª>\ŠÌ4…j/¦‰3÷ƒu"äMi N”¡<8(V;·>Ηyâ7=»n…jSýë]Du8ô±=÷û}D‡ú îÂòsn’yo°F%ñö]R飜Ÿ°×”Ýiv}Ρw¥ » 8KŠ6±&2–ûMü$z¼ ï*¾‡“6ÈC©ã;DÛÄ‚•ÍÉ~̾ {l }UÑç.,jQäîD˜ß§¦,“¯—i65î¯B¸ë5œÏOS¸VÂIKoÊ%=‚™¹Yª§áªIÆê¼»ìºB¶­©e‚ÆŸm¿›5›µ/Ì-³×ÜØ«Ú jõc2ÅÎù—{ñ¸Á©Ìä}|þ—óÝìUD õÃ]óL–­Åë›P“…½ÖaߌVß„L8*ýoû¦úïúæQ1ïO.þ˜f© endstream endobj 172 0 obj << /Type /Page /Contents 173 0 R /Resources 171 0 R /MediaBox [0 0 612 792] /Parent 160 0 R >> endobj 174 0 obj << /D [172 0 R /XYZ 133.768 692.105 null] >> endobj 175 0 obj << /D [172 0 R /XYZ 133.768 667.198 null] >> endobj 177 0 obj << /D [172 0 R /XYZ 133.768 452.859 null] >> endobj 34 0 obj << /D [172 0 R /XYZ 133.768 355.185 null] >> endobj 178 0 obj << /D [172 0 R /XYZ 133.768 333.094 null] >> endobj 179 0 obj << /D [172 0 R /XYZ 133.768 270.905 null] >> endobj 180 0 obj << /D [172 0 R /XYZ 133.768 203.51 null] >> endobj 171 0 obj << /Font << /F31 115 0 R /F8 102 0 R /F27 101 0 R /F28 103 0 R /F36 176 0 R /F26 99 0 R /F30 117 0 R >> /ProcSet [ /PDF /Text ] >> endobj 184 0 obj << /Length 1308 /Filter /FlateDecode >> stream xÚµWÛrâ8}ç+ühªÆŠ.¶,í>åB¨Ì¦’Y 3U›I¥ĵ`³Æ$“ýúm] 68d²•y¢‘Z}ÓÑé6öföú“QçèœO"É)÷FS0†b.<.)"8òFï֧݀`Œý›áq— ¿ßëÞ>‹Ú9¦Ï…¬šk•v~ŽÎA‹$£ˆjí RXˆDì¼ ØÚe¸®Ë0â,ª Ïæt¹:™«lr¾ÎÆVŸÆµ@§˜Óˆ@$ÂþpÙ õÕ8ýŽI8NÊ4ÏÁÖ‚®gˆ›&û—iVvƒˆF;1}ǶëýK•­V^M“q™Ÿöw&vÇþä%)ðM#$$ߦC]:gj5.Ò¥É"`"ô“l¢æ'Ål½PY’-WÎhKBòõÂÖµcŽ¢W× ëyRªxc¡_>ª‘@a(¶—wÀÇHDa¥:j»b"¡`v¯(Ìe Êu‘Ù2úÁm,–¥Vzi–¿7êüãšÙ|ž’À„zãEçö{ØüìaXÞ³Q]€*@\PçÞ°ó§ýÖ…¥8¶áãf-øõµé5 Cg‘1&†‰> endobj 181 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [155.271 326.351 161.733 338.391] /Subtype /Link /A << /S /GoTo /D (Hfootnote.3) >> >> endobj 185 0 obj << /D [183 0 R /XYZ 133.768 692.105 null] >> endobj 38 0 obj << /D [183 0 R /XYZ 133.768 667.198 null] >> endobj 186 0 obj << /D [183 0 R /XYZ 133.768 648.144 null] >> endobj 187 0 obj << /D [183 0 R /XYZ 133.768 604.302 null] >> endobj 188 0 obj << /D [183 0 R /XYZ 133.768 560.017 null] >> endobj 42 0 obj << /D [183 0 R /XYZ 133.768 457.222 null] >> endobj 189 0 obj << /D [183 0 R /XYZ 133.768 435.131 null] >> endobj 190 0 obj << /D [183 0 R /XYZ 133.768 369.371 null] >> endobj 191 0 obj << /D [183 0 R /XYZ 133.768 276.988 null] >> endobj 192 0 obj << /D [183 0 R /XYZ 149.011 141.404 null] >> endobj 182 0 obj << /Font << /F31 115 0 R /F8 102 0 R /F26 99 0 R /F30 117 0 R /F27 101 0 R /F28 103 0 R /F7 116 0 R /F18 127 0 R /F17 129 0 R /F32 131 0 R >> /ProcSet [ /PDF /Text ] >> endobj 196 0 obj << /Length 1551 /Filter /FlateDecode >> stream xÚµXÝ“Ú6¿¿ÂsO¦sè,ù»™>Üå8J{ 7@’N“LÆ€M}6õôÒ¾»’llp.t¦}BÖ®V»¿ý–±6,cxq;»¸¾·©’Ðcž1[Ô¶‰ï†2B-ט-¦ÝëS˲ÌÁo7o½Ï³_®ïƒÆ)O9!È”ü”"Ë…¥o©~¯ïYóP¿:Õ·øêèð=N¿Œß&÷ã-1í+ý€0Ë«n«HqÍbÃqᙹøÊÕVÚ&¹æŠÃ‚šË5çÑ¢Ç|óE˜—Ÿ,jóL}­Å®Ç“'J`‘*³[&ÐPrœJ‹u̶ù-_‹ä1ZóS˜|x^Í-räë)Bí}JIèjÈ“´è!@fekTÜv@•´\o^ÒÆ”9$”²`¹MLß½½ÍF7£ßw/K-‡ØnÐ@öÔîø.kY=H–ïßoÓ¬8µ;ð ®v÷íÐ5è…(ŽùR}ï7ë°×HoÁ:ó,Êž‹:êIt$v XØÆN$¢Q °ü`yM°“ÉxòH#.u[ѾŠí¨,K3µ•öúD‹E™eßÓFËìpÝôÝë׃éô¥l`$ôk„Sˆõl/rN´ïÂ¥Óï­gÄqýÊ¡[ó<{ ¼ïX‹'ü2Hy l¢+~ËšŒ‹uœÎ£X1×V#Açrü¬h¹,Ý…ú(s‘¬‚NÍèk½”+4Bé·Œp(qÃÚˆ "PÝ¡Œ8½Â³ˆøg7lZu›D§çØŒ\è­9ÆuäRಌlm¨Ådxa|”ŒÐ,Z¡­QÒ¡\àʬy)ÏÚõÐs œZ¡Ûö&Ö4ô&þfÊTkÁwØH¹fØè…,{ Rt7Óàw)K¡C+mÝýýÀ³àPeàë/sBs…Õ—A𿢧mÌÕî\¢(%(­ _**¥Ï.4,¾ *lm¥±•E’²ÑÜs èq¢¯šSy[”¥%f¡ãÚJMÇu ªcð<×Û;ì£RWh¦ùlBÆÎ1Ÿ+ö¢€È¿.½ê@“Álø54ªÜMn>|¹½yýëp2~÷ö®+ô±–Î8P·r+$d÷µ%Ž×1}{6˜ êÎEº«¿K¶J ã"Uü?sÏžo U páN ÇÏ[±À¦„UÈËœÿYòd¡OËr»ÛL {˲¢ÜNõ}9æÂúE§y1ÅÞÜ“Í yӲؖ…bI× ¡ÆBgœ¸+À!y)«ÛËå›ç{óËÎN8u_¸B/[æ^%LU[õ`:ÏÕ2Åz#»bü¬¸òX)뀼ÊÒªgâ§HŽ$}í7^YxW²<\*«¦}Rêh¢G™;‘‹9VsÛ÷u%†¦$TçAõ|rê)•¼rs©6¥‡$QûÎ+üú¥[ò¥ˆì©ö èšµo›³Îqröÿeí±Å·öëWs· ]•ÉBÏkXg5–‘Hr•›Ú5;Öý9>èCØÕÒ§'@VõÙ3†`H‹ê—Àý^øjþ\mÕâ'õ³J·> endobj 193 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [369.237 437.2 383.96 449.155] /Subtype /Link /A << /S /GoTo /D (subsection.2.1) >> >> endobj 197 0 obj << /D [195 0 R /XYZ 133.768 692.105 null] >> endobj 46 0 obj << /D [195 0 R /XYZ 133.768 558.661 null] >> endobj 198 0 obj << /D [195 0 R /XYZ 133.768 536.57 null] >> endobj 199 0 obj << /D [195 0 R /XYZ 133.768 480.772 null] >> endobj 200 0 obj << /D [195 0 R /XYZ 133.768 376.711 null] >> endobj 50 0 obj << /D [195 0 R /XYZ 133.768 292.769 null] >> endobj 194 0 obj << /Font << /F31 115 0 R /F8 102 0 R /F28 103 0 R /F26 99 0 R /F30 117 0 R /F27 101 0 R >> /ProcSet [ /PDF /Text ] >> endobj 203 0 obj << /Length 1677 /Filter /FlateDecode >> stream xÚWKsâF¾ûWP>‰ Țѱ©Ö^pH0¦ ›K’¢„4€j…F¥ÇzÙJþ{º§G2ÙIö‚zfº{zº¿~`u¶«su»¼ºÛ¬34‡÷:ËM‡Ù¶9ðüŽ7ä&³ÜÎ2êün8Ý>³,ËXNæ‹n߶mãÃì#Ž±|šÜýºèþ¹üåfìé±Q3„[”Æ‘åÊÒ÷ÞŒù1sßæ¶É}Çô$²®6›"þ&º}—»Æ?Ñ—YÜy‡??¢BPÖg̺ÚÐm³âVlãtlµä–kuýpXÆe"®{Íz!7ås7[_bñœÉ¼ì)í¾o™wzÅý”Ï«Ñ|¡%h}»˜¯OË“ÍÅd:š-iç¯6sk¶‡ùt´šNf£Õãx¼5"Gºf«[Ðöq2»ÿW…wwÓO‹Éãlu÷i:mQv;Z,WOËÞ‰¯V²zº¿ý Ÿbéï TmëˆõÚLÛd/^Ç„&:ŒBÙoóv”ÏÀ¶3µE”:Ð! £4BœŠˆMÇc§ þ®µ‡ŒicÃDJz“5ò§G PÃ4Z—]ß6d·ÏÌU™U%ÑåNhB|-IË ô}éVg Ø®/osÓuœš/8WVy.Ò.ú$ŠRäDgðñ YÄe,Ó.l%yi s<ÓãÍ5ÇÎoÉpÇ´ü†wS¥!ê'GÛ–oZŒŸâªØÉ*‰¨~„R[ËŒ N©”r/Ê]œn‰%‰?wÁnñþ¤r¼RA΢¡0€®Dók¯Öø»“U‹¼^3þJ„™cÁç¤Ø'ÅwrŸ%çx–!¾¸¤E–Ëmì X¹Cª:-¶]ÓvXí5mgQ.bTd†—V mÓ6 Ò¨E+·LϾTڦΘ®ÝDMEVY5P‡Ÿëœ¥aœ†I ¼:`åÂ'ˆŽâ¢Ìãu…0µ‰ºÐv<®#ds¥¹i) ¼¿Œ3ð˜=pÕÓz®͌ÏÅkYçs§?‹½? ýOÆ•uÎÀ3RI'b n3r Ê8¬’ §™G"×R>Ú­ ±©ÒQ*ëRÖáq!õH½_ê[B¹ßkôŸU(ÀÅ:ûâýYdN Ölq¯œÉœ(»äX•x—ë ùÇ1®¥@¸Æ"`Hˆ•Ú;³\Æ×ê](”Ê´‡è(ôð |„d!^ÚÔ7…™@#øQq‹æ]U‚ÊE˜ÇÖ(—“:î2cñÖ‚{ZPñÄ2åùè'AK¿®È$Ï( ÚCA{kUç1Kªz"Zaë8 òÑ{U°¨½cŦ0{„øçüw™w3]ÖäÝFf"E—›&ÊŸ®Ÿ××íÅs½Îm¢×«ó ŠvQBÉMË….`ßòÞºðµû`ãÍ}æ[PϸªhÝÿÆÛD¤‘ªã`$VÑ€•DTY/éôK—bFéy Žgµ™$´*ª,#7Y¬"Ò°V Ö}Ö+Ô Ã¢DäÅM–Çêºbavûƒ¡]·ì–ÈC1 Öª®[0Õ¼¼Æò AZâ\$‡®ï`èîAµV{è‘vã—ËIî²Úse…PÅLP}oO ÊÒÀCíÈLu]È<*ßœ{æ'éãΛ”ð²R¶Ù6}Û;i /St˜øË”ð6˜˜ ï»Áô|ÖQ3B• ýŽNAjP*Õà ‰¿Ê”M…îRUžÖ—p³­Sz't«Š¸¥• ’NÈ/qðŸ¦z®T#$™]¥E¼U÷âŒî°ç õN&Q"ÁÖÓ¡µ%íb:OïV³O#øgÕŒ,×'ðÑ=7^"qlSxUŠKÊõÕ7m£îÛ77Ö¾2#õ[ž®zŒ£!Æ ÚŽÍ=Õšð{/rÌQ ·ÁQÜ ÚWÙ¯GEÙԲʹ¥„ëŽh6Ìü†2Ï«¬zÚI¿µ+W=ºÅô(úAQ£KˆÊöËf¸Ö‡DD"Œ÷AB¢ºFé2C{umB怶pPÞÎÂÿwÏŒ7\x@“eE‹,A·»TÔWàT€ó’6Ïû4ÌŠ/Mإٟ'éˆ&/º¾Mžnv &k' _*ÚçUé\û¨òB{¦²»0’¡ªÞñÉTý -múœ½¢m`æ&ãMç.v›ºÍå_×ô‡¼æªGŠ<(%ŽŽÏëÁGëpQ+FË«Òeö endstream endobj 202 0 obj << /Type /Page /Contents 203 0 R /Resources 201 0 R /MediaBox [0 0 612 792] /Parent 160 0 R >> endobj 204 0 obj << /D [202 0 R /XYZ 133.768 692.105 null] >> endobj 54 0 obj << /D [202 0 R /XYZ 133.768 421.052 null] >> endobj 201 0 obj << /Font << /F31 115 0 R /F8 102 0 R /F28 103 0 R /F26 99 0 R /F14 205 0 R >> /ProcSet [ /PDF /Text ] >> endobj 213 0 obj << /Length 2613 /Filter /FlateDecode >> stream xÚ­YÝsÛ6÷_ÁGjÆ‚ $Áôá&®íœ[Çq#ßÝÜ$ LA®Éð#Ž;ý㻋%Q¦Ó¹k.€Åîo¿àÀ[{÷æäüþäì*â^Ʋ$L¼û•Ç£ˆ¥‰ô’,d<ˆ½û¥÷Ágssýöú~&#ÿõL ÿþúÝíböóýgWò`‡wìo×òYNwâÙUxÈ<ɤL¦´äÍMx·øtûîÓÝ"ú´øçë‹ëÛ7ÏÏáAÊÒ4ÎéªÙ<âÒï6šˆÂ´QÕÊýÖ©Ê–µj[½tk*Ú~$bD»ý×EX·çzmÊ;µÖÏÅI#†ñÀÍ.ÅØ#õ朳,vÚüÄÁmÕ˜‰A^Õõ4 S¿êi«’U´Qziºa[\õ]ݻɅ ÄÞK† d8ˆ¦ˆ½žÅܯÚN7¦jÌóûÄhÅtXôÛÿúÖÓênB[ó Ãl|Õ³®y#¶µ4åzBi ãYx` 3pØ6XV Ž å‡ã|9ª 3$îf¡Ä».òÆÔÍ9uYz3ã>ÜWËj€``)>›‹(òàGúºu»<âÎ ÿ<¹3+²<ç)ã‘«c­KÝ(´|f ÷/®ˆ&iš°•iiÒâÆyÕ7­[dashšØè)­É€ .vj«š­ê&|U°$ÞV5ë~«K¼M·;íùÞqÂ’dg4rÖ;¸È³Ýœ¥^FJ@ë@ŒxAðP²Tò?ít ‹ÅÎEsUŒ±£xZ8‰ó˜Y”ÂN‘CòôhÑá!HíxvÎdè/õJõEw Xá""-àî稿ÎÑ›iiάhÕC¡Kë 4ÛÒ캨@ô'šÕ¥¶%}e=×Qp„ª‘’0ºXÜ>S–ŒX""l’AÇx Š!¢ãÑJt î¥0DD« w(!2ÕÙšÎ|™Y· Žª„ËÀï)ù‚;x$ô“uIv"ˆývSõŒ辂E’A¬—#X\Z=áu ‚ç7—·Ó7çâdç ª\N!£ä8Ü_˜v|Ý'ðX;ºÐ7Ž‡D"÷§×Ê4 'àpU_.‰¶ÁJˆÌWSˆ)ßÜЄu;0a²@ªÔÚ-tV»­Á¦iÛóÌЪ)Á|¯\.")FBwkÀ·f½AÄv4$«r­iLN+üUßõ›kªÕ-ný¢Ó‘ý‘Ï…/:ݤ½o®o/?-î¯ïîn._0;¢fŸYpÙ4á¤ë4ÕöMƒÏÞ'¾ÌâRnOœ Áà ŠënÏ‘Ç& ¹ßv¦® ë:8Ü8ÀŽ¿yµ…Ü­ÝäFO®¬Uº¤²X C›œl–ÂsS_wfn¥; x(,à¤Í¼«„GúÿµßÓ—nƒ–î[9TqÊ3ø‹à›Ê/6 ˆ¿a Qi2öÉ­Vpç‰$É*‡Á~WSŒd‹8$…ƒXqcJ½°jµÂ‘. pƒï8õ¾ŸJà}Ðaî¨Äã‚E2 MqPí† TxQÈ2‘ìëeÆþ †FE¶¶}€j~GÁ±dFEEÕ`òÀáƒ+/ÎU háÉ¡ØÅùŠÒ¶sKŸm!³=ۨȱƒ?(ÊU4óЃkF¤ÿLÄ׬="Þ£›¦^²4’¤jÉ2)=ðÜO|#“ &pn€d¹ÿºu1*Œ˜ˆê嶧htŠ¥Xê# š‰óžÒ­ÒÁýàKå®Ù¨Áï`R¡_¼S߀•Dºm¿6nàÊMOKü¼Ñjð¬U<åy–9 P¿è§XVîÕŒvj†÷½Γ40ë²j¬ÈÀS54¹±å&å[úb}u¼ŽìkLå&·õ&ŠàxLÈâ ‡Óèš­ÙÔeV[gf«l>€[@Ô\jÄá)•£dªxZ£b£Âû¹*5±Âã,©gvî·V»M[(+_™€ž÷Ár…,A $<ý£Ñ_Z!aE<^1¨$U/l¹1dÉñ‘dH¿?2qóÞdÊ«ÅAÔ°I×”yÑï:“WßJµË²ñ_¯lß&D@Z@7€P‚"n{fÑ')k¨–4Ñæ(46-ûm‹ áþH£ÑØÚâ¾P>¸M\×t<'B˜Ê]£‹´ë•æÂ:3<ç‡ß›âùçBcÄŸ?(Ûð[VD²cWÖ¹–ÐÞNï´l® •#pˆÐ¦Ûªi·5ªŒ!Ç@ëøDlÔC#U Î+r—Ž.0©¡ž&îÇ.‰Ú`•f©Ï‡^¦Ãû=$LöÏ ºu!-7Ô`D"¦B‰ð‚~m]D»µÁÉÈ~ƒ ˆA¤êZj…qfÇÅQ6ÏÀïV•¦î q…ØTx—GšXNjsß >ª=…ØUÆ5UhÌIºŸ,ÔE[# '—åUQÙŠ&±ŽÅ9EÃÁpH×&§ÚÖîZQiq,è°$ÍØ#€Þ¯…½ àP@ÖMe-°ìs½DÙ³ÐÕqÈi:è|:â´¦'÷ƒO¦s|vV†¨ý2‚Ô«áBOIi¶döªéÅnö§ëó¿9l Ù¨²­Á—Êüɵ ®³°Í cm_»<ÑØðaŠÊE½;ûá ˆÅ¿ÛoÜ.6°ÿC›ñâ5† N[V†62߀f:ý-ßžçªZ¡­‡£•ònø¨»ü…"BpTC&®†ü\ s|cúqüb!IëÞç?+ !ýÅ£ %–Ž¦Vä#rðDŠY›R¹%€ŸB/AC±#¨ž-Û•ÒÖ5BÖ5Y›V7ßM…§ó¦·áúš[z@+¨Hà@œ/îˆèíx ØSY å[Š6ØRõÔØÁÆüíw8Žý·ªÉ‘ ýmñÃÇ Œf" }}t*UËx*e²³²šŠ h¸Gfe,0–ÂÿA«r~å<ãc3á/¯¬[ÿ{½Uy¡i’!\ªtsÖbŸ{ðñ]<å6÷}ÕöJ"òÏUãNÿúm›t·Û„Ð[½­ûL™`êý…(ÜÎøŠXç>nHÿ§ÞòÅþíº·ÏÒºœ_(CsVX\ºKÊöÍaxN…ÒÎüê(l|·æW{·õBméÛy߶#×¼¼?ùì**¾û?Ü>^çÛ“?Þ>ÂÅX”IïѲn5e¾oÞâä'ú§—^ mJJœL‚ËEЀˆƒ6ØR/¶€S{ÂcÎÄ$wδ@Ø…CºAjûˆl-‚Ô@_ì”fL4ÇWä&¿œ÷+PõjhnG‡'°$Ÿ=Q¶å1KÓƒÇQ*ÙÞVK=ã>5ÞŸ®.//Î_ÿ㾧ƒÿ5Éöÿ 0åÑýl/•Q/E]R²”sŒ®"qH²ášNDŒ}1†‚âÄ8@ÿ‚…"¶Á endstream endobj 212 0 obj << /Type /Page /Contents 213 0 R /Resources 211 0 R /MediaBox [0 0 612 792] /Parent 216 0 R /Annots [ 206 0 R 207 0 R 208 0 R 209 0 R 210 0 R ] >> endobj 206 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [451.759 428.178 458.221 440.217] /Subtype /Link /A << /S /GoTo /D (Hfootnote.4) >> >> endobj 207 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [426.225 391.759 440.947 403.714] /Subtype /Link /A << /S /GoTo /D (subsection.2.2) >> >> endobj 208 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [444.989 391.759 459.712 403.714] /Subtype /Link /A << /S /GoTo /D (subsection.2.3) >> >> endobj 209 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [463.753 391.759 478.476 403.714] /Subtype /Link /A << /S /GoTo /D (subsection.2.5) >> >> endobj 210 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[1 0 0] /Rect [152.144 379.804 166.867 391.759] /Subtype /Link /A << /S /GoTo /D (subsection.2.6) >> >> endobj 214 0 obj << /D [212 0 R /XYZ 133.768 692.105 null] >> endobj 58 0 obj << /D [212 0 R /XYZ 133.768 468.651 null] >> endobj 62 0 obj << /D [212 0 R /XYZ 133.768 222.878 null] >> endobj 215 0 obj << /D [212 0 R /XYZ 149.011 141.092 null] >> endobj 211 0 obj << /Font << /F31 115 0 R /F8 102 0 R /F28 103 0 R /F36 176 0 R /F14 205 0 R /F26 99 0 R /F7 116 0 R /F18 127 0 R /F17 129 0 R /F32 131 0 R >> /ProcSet [ /PDF /Text ] >> endobj 222 0 obj << /Length 2547 /Filter /FlateDecode >> stream xÚYKsã8¾çW¸öÒJU›)ê5{Ù<:Ùô¤;ÞØ;SS3S]´Í؜Ȗ—’:ÃþöʶwzÓ—¤ €öæ½°wyt:>\D¼—³<Io|×ãQÄÒ$ë%¹`<Œ{ãYï÷ =îó0 ƒë«Ï?Žÿ\d;ïDøŽÌA¢ãæYŽBF¯ß>ïG’e)1Ý•ö¸/²8¨š$ŠŽHΤL[‰ÕâÎŃ9‹2Ñrõ'ªÒ3’Z-K$‚²^ø…šµkkÔj^hZM‰s¦ÿ~ÜBŒjåýO*éªëˆB­fÕT­ÝË΄^?,`'ç,½ïÊumʈ–q`–ëB/õê^©îã™qÜ–Ke<Ó)Оt§FRÒ©¸ó«YÍJ|ý¡¢jˆÄ\¯´Ý•ynô¼tz…]FÊ+|YœÙæ™(:p4Ñ+ý@²4ÏèD\¶uü‡Fà«)DK€NMÁ©Ä¾j%ºmð0‹¢ï_wÌD·\à¥>¹=œÅ©èZ©æO»‹x±‹gåcàSó¬þy¤ü½: ñ¦¯UUÚgQÐ4VÑÒÇ@²ç$(„¦Ó¢©Üe#×´) ³šïÙûC7B%DZîz¿â2œ†à¼;àº,f±ÜøäòZ G_N?ŒÆ_nonÆ/]˜…,‹eËNFù;  ß\TêjÖkw¥E'ŠT—Í=;UÖâûîx˜·‘Ÿì¤x$ò`a*"ЪÒÞÓ õÒž$c™ÌZç…XWçV= Í£.ªöp–FQÇMùE/_~ \[h h/H"™Ø@ìO(«WÞº8dqÆ»wv[VµZLU‘sïÊ< †VM(±¡·j©¦¸X™Yb},Áã¯Çq(kʦ¢ ž?'ÚêʽçáÄ®|Ô• m|2S ”…:]§F{{ðÌTúÃÓÌ`gx~AÄ.Š\7…Ïyö³²Ñõ¾Ж¤¼­LmTA£_ÐèKz²/öâ8“š÷àù¯¸Ö«g]2€)oaˆáåÓœ%À.ç„œïò©}juiçjež[¼”B"<z|ò„Üh®6§Û0[·èÇú®>e|˜Iˆë0|è‚¿ªGSkÖn2σ+埞3ú½TÈöD w4ÊH$mLLM„²S´Z«š–^êYY-ÛcÇèZÛ Ú»}ÊîLj25˜ip®)&W†Ö>Ón¨âƤ™ბ> “6 ©„ý0eÐetR}´ÖSŒ yønX;ù¤Ðp*„©KW‘B»ÁEŒÎÁžÂCk?â>‘Pôã®xš»j ;%Ö‡ #Wd,ÎX<™gÁ©ö¼XÿJé&´Ý=&ÌÛcªÚ¬×TÜ©ª®µ]µ [y#ö®‡OÄ."  i|T•S8‰‚ôAU9€—Žb©—¥}"ºÐêž(g‘Æ Ìîh·ãæ4 FO•¥ª¶šX®õÌ6¯¤l¾…\PœNQ{6Á™* ì=Ö°+¡Ñ<לÎóðÖFfþº,ØÊoCò$Œ3TSŽ>ŒþsÄA©°Ç{‰,{q(XÈÓÞtyôûŸaoAo¨[YïÁ±.{‚åö±Eotô/êŽ; H l$È32•Ò¢BsІÂè»<¡•jAàT²;oÀ¦^Š˜³0»>s¡„(B—A.*q‘…P‹Iµ l[P‚…%÷ÜÝ(ì8`G¢lêuS3Ÿ‡IKÉD U!vP,—ɶÙç"®Íê¾:·ÀýV&øNËq¸5Ï7}‰+üè£ü^ZUkcQmܘxÈ‹4>)lúÙsegï*Z–ÖÌÍ AWðHZñ®×ÕßHLÝÔÀ´áãÐÏ!vî£áöòè@÷É“®‹º^ÿäKž2Î- ¬\khx”‘ÕUÙØ©®Ór¦•Â&¿,ÿº‡T¯ZÏ ݳE½,:ƒÑ¾ÃrƼÕÔç i¼ š–££Ž«üØ\è‚Pwä|­ ‹ÞU´yy=$¢À€šXåààM^â#bd×Kä ­ª§êMËåÀ)ÊyÌB!û fDÜÿu°}ïm7—æ^È‘ƒWCUšÈ]¿¸R)‚ñB·Ž&8̺ŽAË@¥¥¶XQÈ8J]^¯-MLÅÆXjm¹$êìÃoð t­2ÎøfªÍª.6¾ù†‰ä±´{÷¨BãZT¶.iæ?õˆ,b±Øï[!‘úc¹šbƒàZ# =QëXÁW¸¹ØP.nR»­ISÓÞŒ €®hËšèJëeW€o1iSQ¡E`„£&E»íZí'¨FúÿA¢Ì#Ñ/ÇÐpAeSª=/ŠôÛÈ2þšÏs–ˆÝt /pÜÃVñ’‹÷Dˆ0 ý…®^[Õô`f pV‹¾Tšì55ûþhüÍEÒ*+~LY £¾ß#Vä;Êʘ'3œÐ_"8‡B˜¦YwhÞ\ÿvyóùËéÍ¿?ŸŸÜþöÒ9hÇaëPWÇâí$ÿÝy4ÅÄÙ@/kóº=Ò‰ì“!¤¥€n¯¦æú'¬ªÑÎÆŒ8”7íX‡±}cvæ%IÔ6O5T™!Ì…tE”É_7Ÿg,Ú~¢pÇ~Rè “) Óhkx_BxVÚ6¹s¾ÞKn«§›`«Ê¥¦Ütw°«ŠÂŠPþ«²Ö v²5ãÝÞ XUÞù>‚&v €ì;ßsÌ—×#[H–‡©ìxٯ塈ÙÖaÙŸ”omxòžÞMÁ(¸¢)Óo´çï(çNÚÓ-zSÖ}l»3‘Ôí¬m™i9…nÛ…a³öÞÿfJ&œÉý”¼¾úüáËh|5^xA¹d|[¿c:Ä®ñ>äDoº˜7„àÅȃƟjœeˆÆ~ÊÁæóŽøµµåJÓüÛk •¨6~¨ø‘Ëo ,ßgº Œ¶6ð­ æ±Í°%V8¨x؃?/O?¢§|cAT'<¥”d鎎¸ýÍâà‘¬ >ÃúÌRà,g[ þ˜ Æó¤#¦ý«™Õ‹#&Ä–÷¹Èã`„@åçòœe{_ǧ; “ÉÝ„¡ ×öà·¢‚†w÷-: åt_¥ðÑöÃ7­]°Á/…Õ´.=bDáÏñi©°6¸êE+«†¸íŒ³>UüÐ]Õ•ûxó# (ßžk2KÄÀX솩„€ðaŠ Ø„¬<ó øÇMljô•ÒÒªöÿ"ñr¥­}w‡Q0ÂñÛ=X‚ØöÛ Ø!£îÎô ­¾¤@Îû²ô`fÇøa¹ë«öôÿׂ°ô endstream endobj 221 0 obj << /Type /Page /Contents 222 0 R /Resources 220 0 R /MediaBox [0 0 612 792] /Parent 216 0 R /Annots [ 217 0 R 224 0 R 218 0 R 219 0 R ] >> endobj 217 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[0 1 1] /Rect [450.331 431.609 478.476 443.564] /Subtype/Link/A<> >> endobj 224 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[0 1 1] /Rect [132.772 419.654 453.815 431.609] /Subtype/Link/A<> >> endobj 218 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[0 1 1] /Rect [265.218 407.699 450.273 419.654] /Subtype/Link/A<> >> endobj 219 0 obj << /Type /Annot /Border[0 0 0]/H/I/C[0 1 1] /Rect [301.23 395.744 418.29 407.699] /Subtype/Link/A<> >> endobj 223 0 obj << /D [221 0 R /XYZ 133.768 692.105 null] >> endobj 66 0 obj << /D [221 0 R /XYZ 133.768 472.913 null] >> endobj 70 0 obj << /D [221 0 R /XYZ 133.768 370.325 null] >> endobj 220 0 obj << /Font << /F31 115 0 R /F8 102 0 R /F28 103 0 R /F26 99 0 R /F27 101 0 R >> /ProcSet [ /PDF /Text ] >> endobj 227 0 obj << /Length 2356 /Filter /FlateDecode >> stream xÚ¥YYsÛÈ~÷¯`ÞÀZsŒ9pÅO¶g]²¤2å$UÙ” F$b`álÿúíž\d/•'Ì=}|} ÜÅfá.>¼zóê͹䋈E¾ð7÷ .% üpáG‚q×[ܤ‹ÿ8árÅ]×uþyöyýûÕåzùß›oÎÃÑ6‰ÛT‡š ÜÃ%¯\{M÷}s.‚ѦU·k% Úê2%&›§ I¯»æ×s¯’f¹Q脯—+ézŽp]Gçjßd»ìGÜdeAëÊ{ûm›}ÛЪ?\®rMãuöC³åJIé\/¬«›uRe{{ÍVÇ©®h[’ë¸XŠÀi÷Kî0${±”\¬8g‘gå÷^7 î~<+4¶”ó˜¥Í–“r´"ÙóS‰ Å"7€ÓaLxļŸ Vú‚%vY"[Àbä;<±yr,6~wý;6<'ÁµÛ¸Øè¿/W §Ð¤~1¹Å €]¿»æ¾¬vq3ŸIt«â"9J¸, ‡“²\ñN?=Kù,†³ªM»ÓRÛÔÄ1süJx°Ñ›*h“‹}ý^o²â:ÞÌÜH&D;@G(¢^«ÊçO¢|RKAÛZ°Ão½+<°uËê-*¥É}`]Žì:›ì/Ò5ÔãÎyö äîÂޅ߀4îT€Ír…­Zf¨€Æ†Àç;uSÁN:Òu.A¿f¸Ü#k: ei$œ`á³(¡Q˜—j!˜«ÑùnF]L‚VW£E7†Oúpœ+ËäÙh|4üoË›1[kk"ðXYù´îÄ 5%ÃB¼Ç›8+ÚhvÍVO-QX" íùÿ1H~Œ ûNd¥Ðu 0F%$£°Æè*Ô²¬ÐUUºlkê¦UŒxx$”¹¤yü6ú[C-©74–6´M¥úY×ÕKë!Ó{BnÕ¼H&G¹õóe(}Gwsõšƒ\P“—³®( ™âawÖ‡ q½¾½xwyº>yw}ö—!7Ò»ýÏÙã`S)ËŸßó'áïSŒÅ]‡sä{cÞ¸ûox£˜ðvzq1cl )»u]²Ü†@<Âo¨Ý”ôó¼ÄPöh‡Þ¡±Ñ…®F{a+\z âá-1©é_Y‘š óX“¦Ò< dü£âÚÇÍH(Ñ¢”?¶"1X4ëŠ1´¬HÊ­®t‘Û€¹ÌB^‘ÚF6àl ‚o apç-úìÈ䣓«·‘èñÆò1æŠÎ<¡UÄ=ÏùŸNšú-6§Ò;¡ÑdSZ‡ ¨ìÜ·E‚DĹe2¶™$y[g´Ž¹-šÛ8ëZ˜js›ß“»Sj‡ "B›7…c0À! à¦A®g­+5³ ˆð®mP²ØÜê‚a¸ªj»ùŒm'Yk{ê'Ú¼Éö¹žÐçwÑp§kB\V/6uð5æ fo«ÊMï^Ãã¼yCÁ ƒçqh(ņQ6m¤Lv˜2ƒ œ%á"Èï„ÌLRÚTÚ´M¬~g|™ƒ}þIf6Ð’¼2nlN!ëû3J±†´5®²Ò„Éõ¨ˆ°ÖHB¤ß$úã`€£Ï8LÎ U›ƒ³ë™Æs™ëÓ0@£ƒRk9m¢iæ¬Hâ}Ý‚g5ˆ…5i u”‚‰ šJ Ô—ÀÜŠs hÔDõÀFua•¹`Ÿ*âØ4®Ûƒæ“sÁãÑAH¼¼º½^ËÛõ?Þþ~ùá©@VÝ®‰Éu‚ñùLúîyŒË^â&±¾lwk¤ü=Gýô*¨3™ª>å·ÞnAñã7) yU™Û‰-e³ØnkÛ@IѤMi8$§B`þ0[—P×åú…®sêÊy0yaÏZ½…Ú$Ÿ©qÆÀ-Él0‚“ËmÝ‚ŸûNEiH°ŽPç–ã}Mu¾lÀ9äàòX„‡j°[ßÁž¯OÏÑX^d§Ge6}y)Èn0£vFÆ Ã]Ž>SHº>dô#¬>”Y:#dÅ\¿7Wàqæ$Жê„ùc„d¾;>ÆP'àØl™–.1àkš ¼[ë/—hq¨Ž]§ŽÀgP§ê€¼KWhRºÎ.6! JǺ½#ל=d®q|)D,¨)1¨ÁÝ z‹ø.·›cšµ¹†õYYe4˜Ù£(Šþ•c&z’ zK(©4BEø›ìPA äÅuPpTwª eŠrb_ŒQƒÃWCvƒÝ¤µi vpÿÀü%WS×wurrñ²nO¾ÌeÏÜUcX dõpŠ¯@#þ›™§rÔžäAÍn¬º¬¾’Ert_kÛ.»1MM¥ct<è7Ò„©éá žtû#N©ó©ý!2®P 0]l1–Ͼ«„SÅí¥ÛNM­ÎÖ7·Ÿ¯®nfÊ‹€¹žC~ŒŽ k¥à¨ŒÊàBD¸ÄŒJ†ãŒ †? s@ 3 žüö5êç¾£õ`MÛº¦‘¬ˆÓÎmÚ$tÍ8•ëû¦[Dß>°Ì¤RãÔ*NÓîB‹wû¼ËF)ƒ«”,¼Ÿ‰ž7ºnXòT €ìÐScßeÜýÖ^’f5¥ßT¬üÂzA==1_qô3†©ÒùP®Ë®\—]âkÇ*®·]æNßÃúÅ,ë,œ’Í©t{¨›^j÷£ÏZ=Ÿì¾Ü“ɉBº¯ISQ|ÊŠ²:`Ëvû'ePÚþ”škL+<ÊåÏîð !‡gó,9Ÿ¼ÏàI ø‘YŸ`jˆáÛ¸¦+ï(cÒö½ªá`¨†ÍcEa !]1óf%”èKUh>¸8:Š¸3L)¥_ï0‹jŽ`¡[ðz. õ#½ œ XèG?çáè–âî—‡T–ý‚Þ`¨³±¥‚åÜÔÛŠÛwsz¦·s’« ¼‹è°TœO³¤ïO4ÿ—Ò±j "™ðÄ/@æ &Ýð/ßäÍö75ñ×î/Bó4ß4Íè!Åö«Õ€+_ªƒ¿ý†áqy†N1¯‡µy6…~&ˆBiªä4ÉvéÔ¶tH²ûïß.±öÓ1yšµÞñ¹ß4!” SmVñã5¸æ¼žýgwvóêO²ì endstream endobj 226 0 obj << /Type /Page /Contents 227 0 R /Resources 225 0 R /MediaBox [0 0 612 792] /Parent 216 0 R >> endobj 228 0 obj << /D [226 0 R /XYZ 133.768 692.105 null] >> endobj 225 0 obj << /Font << /F31 115 0 R /F8 102 0 R /F27 101 0 R /F28 103 0 R /F7 116 0 R >> /ProcSet [ /PDF /Text ] >> endobj 231 0 obj << /Length 2546 /Filter /FlateDecode >> stream xÚYYsÛ8~ϯPåI®D‚Wå)¶e—g}¨,'™­-EÁ6gy¨xÄÎüúíFƒ‡(ʉüb5@ÝèãCÛš Xà wr÷0á¶Í<ן¸`Ür&wëɦþÑŒ[–5ý6¿]^Ü\/þ{÷ǧ3¿·ÌÆe2¡zwqÊ;Ël3™Ù–Ï|)€Ì÷hRœ Z©â!ŒÔÑ̶i•Óï¦×u3’Æ/jmH3fFþ²ëJRQ•Š°‘Àä4¼À¡¼¬–Qo*âåuµ©«Ïô‘>}&D_)k2㜎±Âc"6å±zŒ³o±zÞäEµk‡Àg\xÂl="VXÌ›[=©ól½_¦ï1×me¬&áZ´Õ‚`úû%†—â¬:©â œÌ„å0_8Ûmp¶í‹éÍF›Teç—È°§?ð4Àó¦p¤ò3ÊôÀÒ\Ò-ÀŒ2 “„V¯êGâÁÙ4ƒ.(Š’ºŒsËê$‰331ʵìµ2’W´}jéã,¯Š"/ð¶lÒä°- {=‹Í„dåŸÙMB,æóÁ¢­[q˜í4FFŸº Í–B|DBN…eÙcÙÓ³Æ#;[Àœ íþÓ˜®$ž6‹Z§©‚ëó`ŸšAô=º6V«õ¸â°ãýBO}hRS4jÌzMOŸ9¶è+úG ç“( z:¨p«'ržH–&ôòêÉ0žÂµ¾TüX« BP_8~>à•!‘Ž øÞä„y§ÍÜ¡o¢èÖ¾‘ÊTù™ –©gâ&ñª‹Ÿô¡ÍZƒYS$VÚþ:° à‘ßÁÚ2BË>©TÑ7ªãq[¦898Ó¿ó‚¥q7aE+Þ£=Þâsão¸ Çr¼ é»ýÛvs@jW{Öém$Ëp0'pÙç—b±¼¿›ÿ¹›_@1—Ëf"åFÚ»$JjwW0áÙ]*»UÙZW9äæm\ÙV{ž,o®Þ’LÂö[—_¨RUè)&·Ý}m‡ñÎnç—÷·óëÓùíî¦Èö|Hb%â‰Èç'ˆ5 \¨8&±j_Á1•n(˜é“|/ýЂhÖŽfx8c­Â:w2šù³\1ȸñKBv°¥ ó7G¶4uX>ý¬âª$Š‰*è+Ê“¼%SÊÙyfÒËÛÇ¢mðX}@êT´eÔƒ ܦ\×ø"„Äq]U&s…›÷ÃtÕŠÕ¡¨ÅõwNÙNšZnkIWq¥ŠnÂû"©—ÖÄ‘)Ù{‘H®Ã{äøþô"E¶"ì°&î°rázS¹À¾§ô3RÓ‡¢noGÛ×åüþäë-øæݽ©Â šëøÛ>ñíbþ}qs{7â½àæn™›_°…Ç·“œìÀŠ°TSúäh黆ÒDf£Ñ8ýé™I±õÆT¿&ûV4åä§E¼ª«&³¯L„á„«Øø. ÇÊÀ‚âîBçßrÎø:_g€KvµËø\ôÔFîõèÕs‹3)‰öäæjq;_Ž eß‚’lß)‰Ç€ÁߨPa¥öt˜C2,ÕšˆCR‘öv¨®ä6…© x/ÈAð–è"*!K´P‡ |ARC9\‡QŒŒêIÑÜ1ÒmЊ–ÀAgcè<ÅÀÖ5> Ï€K8Ÿηp!}DyQÀH~ÒgœA”®ú¼ð{I÷&. <ۧ؄äÆÌ’&$¾ŒÄ³áa2ëMÒ9qÀQ$ò¹”ÄŸ·|gÒcÿIØqÚä²M Êva¯AaÈÙ ®°˜@P@©¬4 }µTjŸ#ŠÞÜ,þ}q}δCŽ–ã èÞ_À€…„7L-ü@|Ó†™Î4€0²q AN—äŽH¦*Íáád •4þG£b0©p­=™–ÖT×:”p½Áz«8Cиv7üHÆ~09«Ä;8ö2‘x›‰$¨È]„A?!»@þ8|q^—ÄÐy#F÷1Xh¬33·K!u蘂oÂì@|³µ>Æs¹×Tßâ²2ÔɇoCÈ`œõUhj†ôÀ<6¾Y,Í#y€™Z¸@½˜×m·~’0Æhº€¿*¬܄…Ê"#×T1Ÿ¿Ä!ÓkŸIºÆ‚à½ç2Àz#s‡ä GßL‡1‘õ ÔzFø‚ù_³ ¤Ø;ÁÚ&]dgy6#|ê5kÀ¦q/}Àô$.á,#¹;D˜†„Tl⤛Ï(¼õäöCð™¨0£õž4#ŸZ1]Fº[>†Ã Ö-”îîŒ`O’^õ˜ä«Ð<¬³0UpG‘2·“$5†ü[CSü:Ã:iqò;Éý¾ß›üˆ8 •Fúø5ð&à7±S¼×z‘Ôí)#²R/û_Ëa?fwã+^ 6EŽÞ‰Å‘îNЦ„ÐðݯïÇGŠ(÷|(¢BQñju©ˆŠau¨ˆ:ãEÔi‹( µ€ Úû5"\„ÕÉë"‡‚ ‘= )m> \c>Š¼€Y‚ÿ†–Þ-åïj ûwZZ~“8rýõò’kMN@–~—p„<„!YªÖaŠã…vÁÁ $=o;кŽæÜuWQÏf¢¯v>wQ¸8°öu/Þ½<ähÓ-lž5µ1•?ìôãVØz4âÚ£sðK˜nL©$&}ðêè3û }OáfÒ Åëë‹ì¦ÎýAé²íËH—`¯I²µŽþÞ Ýúô¢{ Ÿ¨ !u'Áèûyové·g!wûÓ2 M3>´Õá×úϬW¶¤¯o?·Ë1ü îæÁãxë!µ¼¸Z\Îï//®ç÷7ggËùÈ3™ƒ]{XÖtݱµ$@ =(ÑÃÞ4¶7è…ß4wй֦ùØÐæ%ûÐ4£U¦Š•U¼Ù«` Ñ\Yù6H$ò¢/¬&¢ÆûhÜɲã¢ká¹ 1ÓÝ~Uª¬ÌLÊ­;ÿ¼€ÇK÷߈×ÛŠ"Øî*bIs»TG¯!æ _Ci\–Ú’DĪÐUItwüÉܾÍßÿGžûú#ï×™öoÀHS9ÂT t5Ö¹>j­Éˆ»;’ {Çw÷'#5pä®Ô*w™e{{ –…(—›AlJývÿjþÑÓUƒ¶Z­û¦#ÎwéñmNo¿|¿ïݵnOõN|üåä_ç·7_¯OG|ÈcÂi[+1&½ÀÓ½cM” ]Êñ‚=]9H(¾lý§m©ªÝs)GZ36“–¿ïmiKÀ¯Ýc5ü'eä> endobj 232 0 obj << /D [230 0 R /XYZ 133.768 692.105 null] >> endobj 229 0 obj << /Font << /F31 115 0 R /F8 102 0 R /F28 103 0 R /F27 101 0 R /F7 116 0 R >> /ProcSet [ /PDF /Text ] >> endobj 235 0 obj << /Length 1603 /Filter /FlateDecode >> stream xÚWmoÛ6þž_á4«"%êýÔ®uÖbK‚Ù+¬CAËŒ#To¨$í¯ßtä8æ|Ç#EÞ=|îÎv³pvqö~}öfñYä‰Hf뛢 M²Y’‹€‡r¶ÞÎþfÙ|ÁÃ0d_>þ±útu¹šÿ³þüf™M¦E8-ÎaQ;§hrºßøöÍR¤“I ?kÅA–º©äÁìÃ?‰,‘ð?úÊðóØ̱ŒÏÎAÈ$a(a„£Z²eù ·d¡HS´cWi’Û›²)M©ªò'YKv7— S}©6•HUº_]X’P´ó…ÈØV¿Å=ÃI‚DÈÙ‚ó —Î{¾'‡‰ƒs„AEþ¿‰ëÕ·õ§‹_×ßÞ_ýyùáÓå{š‹û‰mgʶy;_D©`j»sã ŽÉŒõ­QFÛNÎŒ~0$ c×Ù}·½ÓÜ´=€ÇyEéá®çh;˜UÑ—Έ"ÖŽ¦Mð$T‡q‡¸è„| prz€E3! À"'Fµ °€È½nI{«Ý´¢×ʔ͎z6t(| yŒ(°Æ¥¹¥Z<ê~tÒöï÷³o´Þ.^ õFhþ=$Øf„"ÝSO²wÔézÆÂƈlk¯ñ-yûIh# 6(¶%†_U¤Òª¶ÀÆN×·»^ÕÏ@/t›NhÓ»JtÃZCtKœÇ 2€ ÓҞ̭ýU »L_nFØnç¿1Áyð8>Ez(–ó,bzãò{óª0P$Ï Ü´2$ Tn´Pã€g1àJØh[ãÖͶaÒÔ¡Ø9ˆÿ8h߯®_„GíÉLÃt‚è<€6³.Š<"x‚ˆð&UY—ÆwžÜmÐàݶÂê þã‚ÖS›p}±´;7 ³je‡¿Zm]°÷ÇóÛ5¢è‘ɦn{M;Ýè¾,N ‰Ä#" “ñ])cÉ0 È<Ÿ€µ0cUQ]‘¢+°3uœ7‘œÁUè'T°EÃÝh7Å”]WY àþ G;X¼÷Ÿa(76 nHT½Ó5D;ÔéÁͺ·YICÀ-kHT4>À6üb2·$q"-pS¦AÂ){x£±Í}ÐÚÄð Dÿ¥©UG²®tmyˆkÂ#›åìøÍØÈÏ—2ù>h–xV. ësN"ƒ4K8VïzwQ° Ì£ïÊB/†ŽÎYà¾J$vpRAA‚ašž ùªÙ „QâÜØó™Om$ƒ¥VõkÒ\ðÓñÅ)ãÙ @8a³8Û³X(Ò µB<£fã'Óe‡ÁÝ4V¦\Ü•ú~J `u”Ða‚=5Røù1zÝ¥ˆû‹­Èg~íÔ­Å{^¦¼ m¯,¨·)åÚ¥jdž@‹) ²ÞÓKÕö¾ûÄ+󺈓Bré(¢3›cä”VPë£"Å (hÓ«»ÖiZ¬m¨W´5àLù .¡šd¿^÷o(Tçœø² wh†Ö‘½½ž´0Ä–Öæ´5ˆ™ Z¬{i8wÑÞ,ˆ7Ú6@öª§èý 3Uz8àå3HOžéG@kfñ½)¹ÈwªtÿºˆF¯+œO`¦}iîêIPûzÄZC*ûrÆ*­¾“OŒ-•’ øôçK4pºH„KÑÏÔþðîÉezÀƒÚ\ÙZ~8¦Â4 àñáÍýKƒ'A¸/ÔÝm€ m²—Ód/] ¡ @=7è>nwz@\ó˜ã‘Y%ÄÌ–tFûšc O°x’ÊPµ-ïÊÁŸái¸7?ðŸè%Ý·¯ y|RÈWºÃgaÊ¢ ‘LÂg{wPZ£áa …˪(ìTØ1vÒƒ³±oÃlReáâHª°úˆu…LäÞƒ/]æßiö/Ž#QV}ƒ¹êu%ÔiOé«ÂàÅçŒ'çîÉõx3@ýŽjNoMç#Çû¨±>B«½°CN”ì­;º5  4‹w%ÐÂ4yÉCe­v6£„“<ºçJȪeEÙ‚»ä²$¦JêÇ—»5ôõ4®P+*oi¤hÜÝnì-—½p|ûq}ö/ýGV endstream endobj 234 0 obj << /Type /Page /Contents 235 0 R /Resources 233 0 R /MediaBox [0 0 612 792] /Parent 216 0 R >> endobj 236 0 obj << /D [234 0 R /XYZ 133.768 692.105 null] >> endobj 233 0 obj << /Font << /F31 115 0 R /F8 102 0 R /F27 101 0 R /F28 103 0 R >> /ProcSet [ /PDF /Text ] >> endobj 237 0 obj [500] endobj 238 0 obj [511.1 460 460 511.1 460 306.7 460 511.1 306.7 306.7 460 255.6 817.8 562.2 511.1 511.1 460 421.7 408.9 332.2] endobj 239 0 obj [500] endobj 240 0 obj [531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3] endobj 241 0 obj [590.3 590.3 885.4 885.4 295.1 324.7 531.3 531.3 531.3 531.3 531.3 795.8 472.2 531.3 767.4 826.4 531.3 958.7 1076.8 826.4 295.1 295.1 531.3 885.4 531.3 885.4 826.4 295.1 413.2 413.2 531.3 826.4 295.1 354.2 295.1 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 531.3 295.1 295.1 295.1 826.4 501.7 501.7 826.4 795.8 752.1 767.4 811.1 722.6 693.1 833.5 795.8 382.6 545.5 825.4 663.6 972.9 795.8 826.4 722.6 826.4 781.6 590.3 767.4 795.8 795.8 1091 795.8 795.8 649.3 295.1 531.3 295.1 531.3 295.1 295.1 531.3 590.3 472.2 590.3 472.2 324.7 531.3 590.3 295.1 324.7 560.8 295.1 885.4 590.3 531.3 590.3 560.8 414.1 419.1 413.2 590.3 560.8 767.4 560.8 560.8] endobj 242 0 obj [611.1 611.1 611.1 611.1 611.1 611.1 611.1 611.1 611.1 351.8 351.8 351.8 935.2 578.7 578.7 935.2 896.3] endobj 243 0 obj [514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6 514.6] endobj 244 0 obj [569.5 569.5 569.5 569.5 569.5 569.5 569.5 569.5 569.5 323.4 323.4 323.4 877 538.7 538.7 877 843.3] endobj 245 0 obj [500 500 500 500 500 500 500 500 277.8 277.8 277.8 777.8 472.2 472.2 777.8 750 708.3 722.2 763.9 680.6 652.8 784.7 750 361.1 513.9 777.8 625 916.7 750 777.8 680.6 777.8 736.1 555.6 722.2 750 750 1027.8 750] endobj 246 0 obj [525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525 525] endobj 247 0 obj [583.3 555.6 555.6 833.3 833.3 277.8 305.6 500 500 500 500 500 750 444.4 500 722.2 777.8 500 902.8 1013.9 777.8 277.8 277.8 500 833.3 500 833.3 777.8 277.8 388.9 388.9 500 777.8 277.8 333.3 277.8 500 500 500 500 500 500 500 500 500 500 500 277.8 277.8 277.8 777.8 472.2 472.2 777.8 750 708.3 722.2 763.9 680.6 652.8 784.7 750 361.1 513.9 777.8 625 916.7 750 777.8 680.6 777.8 736.1 555.6 722.2 750 750 1027.8 750 750 611.1 277.8 500 277.8 500 277.8 277.8 500 555.6 444.4 555.6 444.4 305.6 500 555.6 277.8 305.6 527.8 277.8 833.3 555.6 500 555.6 527.8 391.7 394.4 388.9 555.6 527.8 722.2 527.8 527.8 444.4 500 1000] endobj 248 0 obj [638.9 638.9 958.3 958.3 319.4 351.4 575 575 575 575 575 869.4 511.1 597.2 830.6 894.4 575 1041.7 1169.4 894.4 319.4 350 602.8 958.3 575 958.3 894.4 319.4 447.2 447.2 575 894.4 319.4 383.3 319.4 575 575 575 575 575 575 575 575 575 575 575 319.4 319.4 350 894.4 543.1 543.1 894.4 869.4 818.1 830.6 881.9 755.6 723.6 904.2 900 436.1 594.4 901.4 691.7 1091.7 900 863.9 786.1 863.9 862.5 638.9 800 884.7 869.4 1188.9 869.4 869.4 702.8 319.4 602.8 319.4 575 319.4 319.4 559 638.9 511.1 638.9 527.1 351.4 575 638.9 319.4 351.4 606.9 319.4 958.3 638.9 575 638.9 606.9 473.6 453.6 447.2 638.9 606.9 830.6 606.9] endobj 249 0 obj [312.5 562.5 562.5 562.5 562.5 562.5 562.5 562.5 562.5 562.5 562.5 562.5 312.5 312.5 342.6 875 531.2 531.2 875 849.5 799.8 812.5 862.3 738.4 707.2 884.3 879.6 419 581 880.8 675.9 1067.1 879.6 844.9 768.5 844.9 839.1 625 782.4 864.6 849.5 1162 849.5 849.5 687.5 312.5 581 312.5 562.5 312.5 312.5 546.9 625 500 625 513.3 343.7 562.5 625 312.5 343.7 593.7 312.5 937.5 625 562.5 625 593.7 459.5 443.8 437.5 625 593.7 812.5 593.7] endobj 250 0 obj [272 326.4 272 489.6 489.6 489.6 489.6 489.6 489.6 489.6 489.6 489.6 489.6 489.6 272 272 272 761.6 462.4 462.4 761.6 734 693.4 707.2 747.8 666.2 639 768.3 734 353.2 503 761.2 611.8 897.2 734 761.6 666.2 761.6 720.6 544 707.2 734 734 1006 734 734 598.4 272 489.6 272 489.6 272 272 489.6 544 435.2 544 435.2 299.2 489.6 544 272 299.2 516.8 272 816 544 489.6 544 516.8 380.8 386.2 380.8 544 516.8 707.2 516.8 516.8 435.2] endobj 251 0 obj [458.6 458.6 458.6 458.6 458.6 458.6 458.6 458.6 249.6 249.6 249.6 719.8 432.5 432.5 719.8 693.3 654.3 667.6 706.6 628.2 602.1 726.3 693.3 327.6 471.5 719.4 576 850 693.3 719.8 628.2 719.8 680.5 510.9 667.6 693.3 693.3 954.5 693.3 693.3 563.1 249.6 458.6 249.6 458.6 249.6 249.6 458.6 510.9 406.4 510.9 406.4 275.8 458.6 510.9 249.6 275.8 484.7 249.6 772.1 510.9 458.6 510.9 484.7 354.1 359.4 354.1 510.9 484.7 667.6 484.7 484.7] endobj 252 0 obj << /Length1 1372 /Length2 8469 /Length3 0 /Length 9279 /Filter /FlateDecode >> stream xÚ­–eX”[Û÷é”nJ†))in™¡aèNé’în¤CºS$”î”~gïýÜ[Ÿûùú3®ß:ëžk­ë¸hÔ4Ø_¡o!²P{v..a€”²¤.ÀÅJb00H9A@.VP{i DÀ%$Ä …¼…=ÀþÂ|¼Â@~ €ÔÁÓÉÊÂÒÀ$Åü—“à•ÄÉÊ dP¹XBì`9Ì@¶ ¨™ÄÅ“ðÊÖ þW„3@â qrƒ€90¸¸`+3À[ˆ…•=ç_šäíÍ¡–Á®ÿ1¹Aœœa¢LËdÀD‚¡ö¶ž0ăS «iùÿ!뿓˺ÚÚª€ìþJÿ÷¤þdgeëù?P;Wˆ@ †8Ùÿ·«äq’PÛÿSFÞdkeöÊÞÂþ³då,kå«Y¹˜YÌA¶Î¿×!öàÿ–Üß8e¤t´_©±þÏžþmTYÙ»hz:ü›ö/ï¿™ë7æãdå0ÂÆËs„ýþódô_ÅdìÍ `+{ 7?ääòÄ€ñ¼¹Vö`ˆâSÌÉau…`#ñ˜C0þÚP~§Ô_Kÿ €Sú7 Á:ø—xœò¿‰À©ô/ r8ÕÌSã7ñ85€Së7Á²hÿK°óÁ úM0-oL‹Ù¿Ä Ëiµ³ûíÍ8Á €ò/ÂFÃùÏfÿëSlnõÛç/tû#â/;ÔÕéŒ0‹?ÖˆÕÓnóÂÄÛþ0õv¿v8í—‚…Ú[ÙCþ°ÃÄC7 †þ/3L›Ão3¬7Ø­‚þÑ=l>Hç‚iuþ]ï/‚¸AþPsw†·ß°œ¿gÅ“ãbéùc:°\Ü¡Àzpýaí»ý1k˜ûïì¼0£ÄéŸèÿ{s$%¡Þì<° dç†Õiáñòûþ/O3W''ˆ½Ëßï%Øü›[Á®+â1ÃXú5{lÒZæ'S0UŽÌ/iѧRß=Û´o[<ªèȲZ§{[‘N€½‹¼Kí~OáÙîóf\ö,Ð1.uþq×Ít7Ýë…îEº²çŽíÏ #œ¶¦¹Ëc>xÕ™Õ±²D½Â¬ïƒGyjLÒš{¨ßhàz Üz2‚ùteÓmµÂBê^ðШã¦:–…ó†­¸ã&& ­LùY‡¡µ°~=‡¶»âß å~x4»1C‰Šr&_pÁÄZ>¡çûi­A€]ˆ¯7t+{¯2§©¬qB™ó#E÷Žþ:뽬”‡û§kCº­ÖªÛ-é•‘ ‘±nл¸EÑ!í›ùÎÇ1Röš­´” ðZ*R„í—82ü>8½î€ÿ0›1ÊÆÎøªxÁèŒÓ m—Tt»Å·ú4/!\ò=êcí%E¹¥W•Ý×mnGÏÌ[ùż<¦QLÈôí¯ÎwU&$4ús0Ž­Ò][á8r’ÞÙÕ_KñĆàÁÅðDFÄ’iÜ&Í‹9„Ïì⇣ÃVkDv?¯©6½IÃÁvA?§qµt_ƒ Y«³*èö*6G"ëÀÁþ1 šÏ•ŠQ¯ÂÔ:¸Ïþõ¹Ô@xd-Á=–C²ûgâàæÛ¬w ½ALLâ'ZµTÔL­?½,ÙüM¼9ùݵW—Rb*gCÆâ©À#4c?hç óJ}¡hö &–ÉœQmm! ¢ …´c‰EçÉ3ú(éQÙ%ïô”§¬X•»¨‰ûÇ‹ú±¥:"á⑶kè\0ríýtôä­rÔï{iÄïÙ<"!»;.‚±ˆ=}­ý¢V…grÙ¾îQ¿ôí[tAw ó)rÇý¨"Þ–Í\ÐC¨ÐÍþ½¬($÷œíÅpé)3®«[rß9—ô⡶| u¨L¾¯„®¢1$ ùÃ߸NnUÈ›‰mjP‚rŸµ¬n^­ÏíR(pЖb@b‡ºô2KÏ7{³¶¼ÁóçmºgUƒe1}ç‹yÆ®«“u ½Š(ÒØÂö;Ì7Vì¨5mžAÑS6(Âl@EfùBܽHº<·Fu,«ø¸t|óßœ¶*OÍuŽÞPQÞ¾º{Š£Yšë¿°Ù¿RV¹Gï[žV;lÕ=ÏõÖ+ )ê8´Ö•¹ì§^³>Æsø±ªJmˆÖŠ$®•o6 È1~$å½…ó¬Ê•˜•ŽºÔ¸_*‰BTsê²íÌïJ½ý>ñËñ„aó¿XÖš{¿¯6»{]—•»7ò%‰/ôíë{]$aŸƒ}9Ú‘wñ„Ûž‡Mú­â ³l ƒÛ¬÷(+7Ò$¯ ³²â]„øÃøA)$· ßíÙ¸Ó×[_Q‹ÏÓ.õ /òg,|YKðã令ˆî»Ý’m —“EÂA"ë¿/n­L£9_Ì3XîuÖ©l1[ð6™°áX½dÚø…§l¹Þsc±–}f;3ß[ssЮÏÌ‘æãGfÕ ŒëÜ…f~aßIN Õê&´¨Q #iøãN¶b¸·bÀ) sêÆ'9#‰Œ½ñ 0`¢‡­"öfåµAƒ­"¼ªÜEb*ûy™èã"ëNŸ'o­Ít…™ÙbŽë¸2ÙõœÞ,z3;†Ü1=9SîZâzàd…D™e›Å-gaLU³n@Ç%oº’"SÃÃÍ6‹ 4€SÁõ]Hë•6ï`†–%“ãóŸœÅï !üô—"7?ž7Aù7ó ò² Tª(Ïî^I»Ï6ÂÃÁû 2ÏòŽ*ÁKPëÁ},²:›lC'FpSS_kg&µ-®‚öõåmÕ1 nW=ÜSé¸ß·_.¿z_L·¦É$F·Aúo$é;ÙìQYK£Ãw|±PbíL £¨‰Š;à…ÜG2²6È9ZºY»g@íz*¥!¹îgYÚXN0 üUÈƉ°ç¯sµ‹Ö™ÄP’wjäD—nƒt¥ë´¾ÀJ™ÿW4¤4"©\VM¸ ÕÇyöxZ³Ò^ŒoDr‡)P,¶Ç„i)‚džá{9 $ðË€ý±ÉàSÚS„ Á\­nüm­gS¹åN׭ﮓ¤òLl‚V¿æW]Z«×«òU×1€¾Ýòõ°Ýó„i%¼Ðœk±#'XÊ®·á˜üµm÷¡ÃÎá;Ù÷Å™h¶1$ûñô0|òw†ÄA×-?þ"õ¸÷ˆõòµ1€EøÆP¼$Õ–ÉxRkžá‹íçt7n×: 1ÇxJMÛ4t,ko7Æã;»8é†ÙqÇN@=åš©c鞨}/Aœ­œnè/.Ù{ ¤]Ìæî.ºÇŠYÚ{èùñìvÚGÂ1 ± >Ñ)¥ô††&ŸŒÆþD,q¹@ï?&ótURö¼ê¬ð¦Ö”7EÍ"„ïÅTÓ $¥ã îÄ ÏIEH‡Ö7ö(2âÎï빰ø\F=x sú|_@€µ™j£MÌ–êÒ´k}K²_U?@gS\§‚—s'J´uÑ«+ªÖ}>íå$9¼Zü‰Â̓àå.&%Ìp'-~ FM2–ÍìÌOXð†'%„Î%¼Í9»Ø‹99ù¦Jy‹,é?fÉ{¦Û à{Ó×°=0àë„ê8öñéŠÉôù¨yÍžo÷< ²5ŽuJo¬´wAÚ‡Rõ£cãæ.>د߂ÃûË6>²«øVÅ.³/ÂËËX,·ÍÈÛGÖýäì¸VG#é#÷ ‰âgmVMYì³…þ†«¾È~,éÙÅñ¿Ú•°>é8Ÿ¿Q®áÛI¹¦Ølõà…{Yö˸ˆ¨¾¶d&A)O} ÇžÑô#^úcAh‚î5F‘˜Âšß¤‡@äÖð.€7i¼5¡d<Ãï½ `Z(¹Rx~¨PÓˆGyIø ý]S›pz¢pj:Ëåax£ýö‡÷qÓ€â‘wÅ÷+kߺ´…,ӥֲέš÷„v@oz# WdžÂÈʈaö6jg;#Ýü@ƒñmŽ•¾OñLݱÍvŠ«/ñs%?ºÞ®©wƒÇ¬(g»iÔHÖwh+„æºeçšv&ƒº4Ž¾þžíÞïÔÑÂÀ"ØŽ ‘»ÒUÂãxuSt}Å|—¦»­/*õ^¸ÆXúÙ!/ÏR@ôÔvßÆ80—åP•åÂGyÕfÛÜuy¯+ ãÕ»íCÁk¿ðguy¾ ,‹ø÷³Iô+¤|hÂŽP!;ÕV1®XQS‰OŸ«$¢ãïö}/Öˆñbäñ¶7à_7ñiõw[f ;WçÛ³ ±S²0NÖÒaòöŠÚû](c÷^F$"Y²¡ö˜`‘€7¹¦zÌ|'½”žªÚ¹xþžM‘­L£¡(¸C¦.Œ¯fÍfåÜ…¼+Dºû0’'Ám?Ͻu›‡:œ!x½aš±Å£ÐXÌD?W#CÄäµw0_BßÑ@ôiÛ÷“±ŒgsƆTÇNdG$Y×¢wûÆò¶«’Áú<ãç¾/†qZˆÔ´OÂoöÓXF̾}½î4a½H¯¼†¦ŒghCqàXL=ÇNF3œÆ'å§Çåöò±.¨'^äÒþ÷Æ;ØÖ',jÇÔ`„ '`ïm9œ®Ÿ"EÈb<ûµ"Ѿ VºÁ6Br1mïôý¾õ×`ãA1?V™!{áÕ9À³ôcNøÔºk¿öëè|~r_÷i‚¹ò p»:Ü>cì.RìZ0HÂèõXev\ŠOÎFç÷½ÙÏQLº1™¦”#¦yómÿ¼–n™«%g°@¾.Ä98zM©eûÃé]üêiô÷îÉDíO¡j>Y‰I£Zfd×tÐNsÛÞ¨Ãù‘[" û=ÿÊdÄ!’t)þz!>È >ñK^séi†h—ÑP_/_ 0ø²Ce“ GwÏ£SsÝ?ÊyÓ¿Ä27ÿœ0¢4~¬ÜFüBµB…•A¿³£ó°¢ä˜)Šïïqx›'J›Þ—L²{àyA.ÅŒRBúT7ÿp À!–0(sj¥=WGBß^ÍÛò::QPˆ’¡þÒlEç+ƒçЄKŸa{>¤£òúœnf€Ïo©šh~<]ŽõùGC@BèöPã„ŠÕçÌÄoä¹Mó¿ ÍJÎÍtcÔ6à‡¤ÔrÛÑË̲\⽤gî:ŠƒÓ ·AûLJìÆ⸻#ÁÎÏÒg½æOnº½ºJ‹5r§&kÜ_H e«MtÖÚgDs¼îÞXLBŸ4dejX%ëwm)ª’Ú‹{ÀƒBº™FEÕ§š-×ÛÉPÙ¹Ãn=)X_]ê0>éc¡t2$²å¥i”"S“æ¸_¶F’ë¹êx¤ÛÈRöƳK›€ïÕ \Mf¹VéŒlåWÇ"J­ùRú 9úéψ+5³^²Õågt÷Ê-ëF ¾Æ³Æ&ôr)™7SßDtê"Y³£ ÚrÏ™ÉøªSžñÊW€—u´ìÙ|ÕG”û$¯PsM}™›ƒº¤‰Z*âô¬#Ñ^ÍVØÄAzGÀ£F:€oó¶¹_Z¾dþµŒb9ÁÎÇus›äs¾À`ÕüÜGë;KÏGÄ_öïžds5xìçpÚ€ÒßA°ÆÀA^ÅÁs÷ñ«·;³!Qx&úÍ°O¾­Ÿ[?[ó«÷Éiüë“%*—¹näàÑd%”„T)–—ÈÿÈ ²'2nô7Áu¼ÈœáLU/ܳ†GsA 4ðž‘‘WbßÜÖ¼E'h¼Ä£;k~rÕ:!”ó³[/Cü2ÛmK/[Ø•ÌüøƒP}µñ}Y¼…%¦ª—†PFì‹õ0qÖË4c¢Òþ@Þ(cõ¢é‰ §2L¢:*‘& ŒKƒi3Þ#-‹˜ñQ‚y¶È•dÕŒÄñ~Œ¨t¹÷ -–[‚ØÕ.ž$’ñ„vÁG“ñoñÌ0CLÏ>™÷¬§™Üï_N—<ïïãìÂô쳃h饾xw¶aË…“R,%7w«pXÌùBmÄFÿäP­ÎŸ5p-õŒé×åðésB³˜‰ BmÛíÒ\hÝ·r‡œ¥37þ®üá*åVÊ bÛ0wê™ÐÃ3Á^Üüy/ ƒ8·È˜õ¾7©ø[ê;Ü)ÙÚÚåO.˜Ä·Èöí îê í#Ÿ‘%+ÿC£!qé\÷0†Œc*w`Ù«V¤+ —WÒÖ ½—a[ÒÅÒ‰ö€wGá鸭ƒJXÇ®ÈÛ!ýìÁÉš‹¦sWÉšº‡­óɧ‘oÍ”E‘Mm%ð»î6P;ž5;ˆ«>Œ‚FçHk;¯ læã ¬ÄÈ’dè}2œ5ñðê×TZ—stŒï%ÛnþVÃYøi™CÉK´ñ°eã—ëÎÚƒo}Ñ;ñ-¥›zÂCnšBWVöÝ#NÓ…*3tüÀ•L8© ð½Í÷æÜ }ždü›<@J%_WÚÇ°i*öúFù6Ÿ.Ù¹û‘åP’àØg®3ÇêD{–&n ÷Ö‚–Ô.ˆ‹‘&I…&]:B¶¯7—{ÅêéÊ]µMÀ#¹ÏýNå:CSVÀLûœû3v#´æ9ù~àü]l¾nUÕ8u"èE‰{<§Êµ$sìi†À$’z^ù§hUØþ‡O;´ˆ•·_ñÝIh ËhPïôðçrÊ?~  ÌÉòŸ-ÿ$ÒíŠ#¡Õ^|¸Q¦J]‚l5I3hfkåT±2.Ë鱉~Å»¿ ĽeTêgVl-ü&ðž£A{qöí)eТÀ×ì†Ïuz‘³¨ZœÃ;o\®–Ï\òçÑW«Û¯‡ìâ†<Ø¥>À«¯\§â_+T6À»«C_÷†ø}fØ=ÍmOQ¬¼b^u“ˆ­%¡:?u‚7BÊHPº±­½NK—¡—Š`Áðþ[Ž^é'D GÙ<{èâ«Umä°{™VO#õwxpTöÓV+Ù®q?÷B,Ó®›CÄxŸ?¹¯¸Ì¦½Î—GXuÔÚß¾%fNPå‡ËTæy¼×Ëa¾P£Š•¨XoÂ'Çc?O~ÀɨAõý$ÝX¶Ë¸ÿì„üÖ´Âh5ÐX±½ˆ†îõË¸î ±¶r”ÚYbͳ^E:"F¾•ñZàOv·)\s/ù_µíà›iV‘¨A§:»(ÛïÖªŸ?ó‡º×œ”@úx6~8Ê«˜iÉJøXô…Æ{LªÏ¸fKE±ÊHg×xyzÌÓQ‰’%”Ä’™Ä²‹/U«Z÷Û98ƒP—'¢5Ûn éü ½ï£÷”wÕþ%üÝ)*¨÷õ†E’úÝš©ñ¥+ÜÞZþýðó”¥"ê16óÄmøÂAÃe®ÄŸóî‰øÕRLÅ%¼Ñ#ä €ìœ¬$C+“ÜUÉ®½Áá87¶{ašÅE"_z@å­u²½µÌ–m1>Ü1ÛÁAkÎ\ Ó倢½Ë§ÏóêfȦßf°BE:ÄîØ”€‚o? ÒÚš…,ZX4Æjl’Š³„;¤O/úÛ×Ô,doIO±±P=Fy2tÊØaw‘§äe%} ²ÈM}7µ°oUB-¶’€)­¬¯ý¸ðÂ~?28…Ù±²ŠèK(PàiK®êÕÝ^–á—¦±S)¯íÃ2:._éoÓ—”¬¨rØ÷kvµoÊMÅM‡Î~7ÍW³º2Ð7Ð.ר«h¸qN·È‘=õââää (麨”ôô6ü)ί’@ºËf›çTæ9árKí5/¸²A›á–õõ.!p ƒo€ßäÝf¸º0Ié9¹Ud©)Jž¥îa;ö•+x5 âRIÐHÇc>¨äÊMc®P2ÕK)PŒT0ÉîIVáߤ-¾ÒÜ !`¿~‰"À&¼,^PDeï^þ6šÖÇá’ׯéÌïØÝÍIÿ²WO?Ôp©ÿŠFæ»2ÚU gïF°8ÞF˜áeQâö¥~Syé,­ñl$²âØÉwÑ=ß:ÚEÒŠÚè©ÀŠÑyÖ]ã'¥gÄQ1‚X®J<ð hKzöíÇŒ=ßœÜÀÃã‰Uœ~–²­jц†š/øàh׸@"me=ïsÃŒ`]º 3þzãp í SŠ^4«÷,bVÔ=ïàHpupÝ€M7|IG…j´ÁÃTÊHöå_º "Ó¿j‰"ø!ö Ã?¾Ý«'eLÈæ 7*fs¢>8éê•íµò‘)=ßW<óó1½ A.ëw&ÌÅXÝúòkGSo±X+­Ë“¡£1ö›¹äiÊø¥Çµ?¯ŒžÄÏ_?¬Æ†¤w…¤ÌD‚†$ØD·>z@tñ Gáö¶ªsÔ˜õý5´ékÓ­°=ñœQ\b^µ˜óýâ•!I׈X&FãþæïOäMo¤ÆaOÃÎáçkh}âwÄ¢Ò²åW9%lß°9+Ù™Á…BÚÀðZ¢o— H8‘æš°—Oç™”OøÏkWí8)—ôßÄ» ƒˆôdY®š™Ò’𨮊#øWA6çGÕrÁ 4½ŒíGÊ.R;Rªñ,RÛ¨yò§ƒ ’¯å_?Ë<:]÷òôXéGXë)»‘\õäÆ¡+p²Juä<)nàˆ ¢0r†}Ü|‡&ÅÞ +­3aà•Š£—§pŸlÆúc5ËÀèç™sÆeÐ嶦ÇÊÅjrëBD¯¡c¼«%X@{aÃá4(í³ çàë¬ìňE[öB‰PÏ{dWâºL|« ÎT¢®HŸ”au™ââm™A™/™›™lOÀyÍr”LˆlÞ\ˆ:ÓVpÞà-o=MLUZe»Ò*øòì6«Ñç½¼—Ÿã;œ—*.DFŽû 3÷§öÕÂ÷ 2‚#ùµ E´ÆY’ˆ‚,MœubþCê endstream endobj 253 0 obj << /Type /FontDescriptor /FontName /ECWVAP+CMBX10 /Flags 4 /FontBBox [-301 -250 1164 946] /Ascent 694 /CapHeight 686 /Descent -194 /ItalicAngle 0 /StemV 114 /XHeight 444 /CharSet (/C/D/E/I/L/R/S/T/U/V/a/b/c/comma/d/e/eight/fi/five/four/g/i/k/l/m/n/nine/o/one/p/period/r/s/seven/six/t/three/two/u/v/x/zero) /FontFile 252 0 R >> endobj 254 0 obj << /Length1 1260 /Length2 6042 /Length3 0 /Length 6797 /Filter /FlateDecode >> stream xÚ­”e\”k»·)é‘fè†îNéîº;¥AénE@JºD@PJ¥;†”PRàµÖ~–îg}÷—û8óW°2êèóÈÙÃí Êp˜ˆ$PД7ñ@¼|¸¬¬ [/(¦hë€ÄÄ@9oG?$,. (.$ˆË P€»ù{@¼ œ‰ä\!P°-  iëåqEÖÛºôá`(ÄËŸ çâÐû+àñ„xø@ìyqA €=ì°ƒ8Ba¸À¿©Áà‘ÌöÞnÿqù@<<‘¢H‘œ¤D{8ÌÅ`qÀjÁ‘½ H%ÿ?Dýwqeo-[׿Êÿ=¥ÿã·u…ºøÿOÜÕÍÛ âЄÛC<`ÿj ùGœ<Üåÿ´Qó²u‚å`Ž.ß?&¨§2Ôb¯õ;l]^>>2ùýçÏò¿š)ÁÀp{( y „„¶¶þ¸È“$!@ …ÙCü?¤b / î…L G p€{àþµÂ" Â_¦H Tú—D@µß$ jüK¢‚ Áo 2Òè_Bî:Ðö7‰€v¿ Ùü/øø@û?BþEäò€ÿlØ¿¤>¨Ï!üHÜÛãÈÇ?©ú"¥9ÿHm. Rœëo!ÅÁ~·B¦Â 0È~¤Zø¿(ˆL†ÿ/7R›Ûo7r1nÈ«ÿc¹ äHÿBjõüÝï/‚ø@þP€ ÷D’ß Èš )ÇËÉòÇt ðò…ÿ‘€\ƒ÷oD¾(ÀÊýßã,/÷ äAœ‡Yˆñÿ¯@°·‡æõ÷K¼ÿa(ò A ~0îü ,õ4«%¦*D©ìóë\¨òŽ­©ZMï&»ñ"çÒP]*?©»s­4š\Wç’n?ØfðýEãߤ;¦|îžš=}·íc³ÐNcrš«é¿åÆt¹OÔÙ2õã@UûëÊHUºiù`Á÷û%:Š;XKŒ(}æ>oûò¢„EL”s] c£Ùõˆ³Ý«ž Æ.û§?ÇXžˆ y‹ÝöxñÞåMz]†]üâÎÝ~ÌÈæBý(ÓŸav:zAÚfù*á]¬™cš\ûËÎ|‰!dîrš˜7Å~Æíe‘ó¦ÇmáÍTa¹Ù•66•àk•¸'"ÐøŽîrFC”†Ô:¶Ð‰ÖåÒ.'3­súѲZ'u•ûæg‡ko' “;zÙøÌ 6Ê}Â:Žn‡äP68+ÛTÝÀ>!r½2Ž•*Öø¾ÈúRÈ«|…W›ÇR+OÓ`"TšfQšÍ·/ÝG«Öd0úGá ¶ÂQÑê¡Aò¤Wóׂª‚ä·¯K….*…ÒG¹$Å¡±­ËÁÔ_ò÷„×L“AY€Ð—0Ééc7}<¹™Þ,´(µ&×çJ¤Y94–¨nôLIèd¿‚Á]þ5ËW¯â%{åÛa¢&Òtrô±\È“†[>êŠ{ûÅ“è3(’â­Ùâ¥çµöÇ6k¾Š ¾—­@Þ~œ½Ùã±è³¿Œ‹–ø­àm"KÛívL$pÏÃ;‚P©¥ã{?_¬üNßo*WN F”mnR›Fñ4b>ýï%ž%÷sÔ¿[t¼WD}˜Ù§cVÔ+øåae© š—‡²w@š÷ä½ìõªªnr¾'â‚lzBS óbIX@ç¬(—™'µoÐb¬¦Ìe½k0ý¼¦Ôo)z‘ci«ymP·9zÆ¡,· Ûq•9¿¢½Ùð}—"çÙ³Ó7±6óÈ©LSbë¥hÜÕ<?b'lÿ¥“ìk¾Ÿ¿¸ŸLÎñ ·|^¶/¶5¸ó97ÕØ2mp3ªŒjhae4Ã2¾ÒÎÓÌþÚ¦ºüEñ©ƒ‚²?×91©•ÝÊ€O5Me¤‘”“ê»òoì†ÍÅ›º1ï.øw±žÒ®¾*Þ»¹½ÿöm")÷LRàñÃCIg¢S’º`ã ìˆ M?øW©ÞðFÆ!mÞý#Ѻ#êàn8袾Œå¨9‚¬DîêxQ¹l¦<‡Î™±³üÁÈL±“²Š#)³Ÿ¡#+ø< Ź½oÄ«GÕk”X3”N¬¢¢51©Šðdæ¼ ­–BLÝY¤½üË·¨„óså6ii2¢ú¤cÊç¹ôÏAõ!|žx1Óü˜ø šö‘ô±zö¤Cú‹%cŠ‰aâ »µ…}Ú´G;ɳp2Y»ŸEÛJU $s¥í’Œ!_¦Jƒ£òï;‹øó²‚-YÚ~&×s‘éÊÆ•|F¬òAR™Šn—%£W2ûB=6-„3ÔûŽ÷Ÿ´^ƒ{Ƀe¦œM:RÑ¿—^´zf½SîáV»`áîh5áÙ9Ù¼`æ¥k ã ‚>VÕôLzoËS=>—žýùÔqvUNCêµ]|Š[“|©~×¹mß }2ðå³\¯ÐÞm•‡3¦a4ªeAmyÞÑŒ`ȇÐ5sª’­Ð‹JëâÐn2£Æbð¬(ÂåO³tAì–-,]£Š¯&dÐÑPóRG…5D-¾Ý ž‹} zzÞ`º—~Nœ~ÿ2ô(Mª7‡:Æ£`ÊÉõÔ¤ÆùgFcË'>w‘¬`jiU'v+üG…DḦÉþíy/—³òÂØ®ÈòçŸìÔß<ö5–˜Â©š8² ¨ªžÍ --€eʽEÌx½¿ô G}hæ]Ýà÷òÐB­ªtÝÍ‘£éêo£9í]Z«ßЖóžÎ DuM¨¸#ŸX†§&$ÂCñ‚ä£{3æa{‘$¦î$‰@z¥±ƒêsù“bÆŽßÕ}×?¦GóûäJÙ‚ßä4ºp .Ê pÛpYV˜äY„UhMÉ{˜pMµô›ŸÍçë0yž”µ*¶MånÔÆ,NMÔˆv‡ Ýl§ñð̤ è¦õv'ÜôŒB }:¿¦Qè=™eUíÄ=Üy«é†<¯žerßåÓzŠ¨Y§ªï}½ø&[ª6¥¾•—øLz‘"êX›GýúÙà %î¾'+SûÑ«uuFnynR)+šÿ–…õürÏhO‚ÍøãS_n…’~ÝKgÉJœàÀ™bæÏmm<Ìƹî'4øŠ3µ<3Ç[ùu#´3í)zAh¥áô‡R>óä>÷ ­Žzk»y³ý|KûÌæ°§j¹“åÑ)zLÃ?ýTö+¿›ˆï}Ñ,¹LO‚ö^pÃ})âw†>]†·ÀQÜž×÷·öMÝÏåã)Á[âúªB+FÜû{ÓˆåžòæwQ¿’ÀzV߀_ç0ïC`ô ÿÄ<&ÇçŽæA,ïG†4ÃIØÌâz|UfVhkÀxâÖÕ~`î›>V=éKS:ÛRGý^ÞnmZÀÈÖ¥^áÍ©Äy%¥µíší#ž2ºà"›SC ìÓjþº kÔ¬Þ ŒCã¸x™ÊÎ-7VqŒ–h“’S&“vþÔOý¬Ù¢ú ‘ô`ê±ÕH}ó{š©¬àÐ鸆šøŒ¿oJÇç\ §YÜ1ºõ”fré}wÂ0ÑÅ|mh&yQbœœul<ÑÇ`@9@JíÐD•Ó­²É`°³­¶qƒ¼üŸ§!¨+!ŸP‚çç>}èÐhm¤¬èNÖbß:<9̵'(°Î3ðŠÂÂ"£K­õH<ŠÆ™1CË˳+«¹óP9£ÆÈ3ÎzÅj’ `?C™1¯G·Ì±XÎùê_xB±ô=q"Ë@jtÊXdcƒÂÛŒ°Ïòè_ËGÁêIaª•yeÎßoLxO׀νB:wi;äox¸Eü1¿ÇE bLAßâß·’(Š8ÌHŠˆ™ÓÈ¿{n0jû¥¡ #•fV©}ù=–¸ç…ÜêjÃ*Ì`á¼j/Ö²øq— –]M=ù×al W&tY&ü×òu<”B܆ÈrcUø"Q®SD<µï@·®{4¢–É—¼ `ŸAÙ«Q­là)¬ÿ\vß•s,qˆ}¥nc–I”³«TyØ¥/Kh‰hyY¢N¥e¢wÿPL4+gîƒÿC) y~:vñÓ­ é»xú#TåT÷Ÿ²×Î~•«w/¢exË{ ‡¦¼o&ƒ‡î½Nô&ƒŠ“‡# ´ Gמ™i=¸|Þ”j[r8}íAe‘ç+± >œoY”K!âÇšÊÏuYŽ6c–XÊ¢Z ÀcÂ@û1bäYá;½ìˆ–ºëú@ðÓÓ¯pG9 8K5EÈ ¡ž1˜v¦Æ‰eE0ær“ÊûC7 ›¥áG¼¡‡¾Ài2Þn–°§iÅÙQã¡ü]-¡¬U–³ïaàÞzãr V`½ªås£‰A‘;°4püÃäºÒ¤|ÓFÂÙI˜㛣íÆ@Ý®­NÓì`«øËǹïb_¾ÍVWkZÛmš*´º­”pØ'Åœ‰Ô¿»Úãô‰hJ_ø¼%Wg2/è½íŸw‹g §ÀÀYÉÅó V~/€™¥øuÓfOÇOò]üµ¹ÌÊÜ©Ô”ú‚/£3»”;Õ¼& Ï’˜²q/¨€Ø&óåÃlemù퉹æ²CéC­GàhVà‡Ã¬\#Is•±íj „aažêÑÛ)£5º §É2Íñ€Ð–ú0—s›œA^îR¶f9hԨĞc⧕€Fdˆ¿ÂÂ+Ä'ºÔU«7´ÌRqr¬Ö¤¿Œó+MmÜ° ³Èú­Òoâi¤ja+FCe2{Äw¶m"îazõ3_†ä;j%¶¾Å‚:“'ÂQÏždÀÊEöý¾xÑ.²Åµà`ÓÚYÆÕ©õêl4 FÚ[–+–¸¦f%iŒ`@]õGÛ‘ð"æ[— ×:Ê”…ÙŽÅÉ‘˜ÝRÊ3¥6›€® ¼~ê•ÖÐjƒy”n ¼Á§N+ÈÅ+tÀ9H*}Á¤ÌQÉÊ(K™ŠÑMŒØ¨Ë{O© S,Ÿ»Ë}w;¦lÖZ,£cóõÅk¼Ú.Å)Q1ª«ÎÚ4VÜfÞ ¨–èöø­RªZ'·¯ov¤n’E: &¾â´JAs«~ ÆckôÑœ$ -Õ0±³‘¡õW"'…P›·;Š¹4ÅèíéçÔÂMì7=C{Xtq€Ÿ¡—²¡–šð9fÐÊ¿4UŽ†R¼¡ÇViNˆ”N!7)0D÷Ë|a%P(£Ð¼Â9æ+(µd@âDÂMfÝè*1ôxC¶ôËJæ nTð(Ó•[u,‰Î}Ð$Sû5o«U…‚‰¨ìƒ2Cº WD¦Êó v ¢m ’àòxÁP^2єԣ/Bãy¢¬Ùª£÷eëх׳’ù«x ”?S)v&Ó߈± Ñ8¶½ ã¿,±QU|rèÚ1¤4em4#tD©‰¥¹¶7kÖÞÊÓ{û¥¢¢Ÿp©šÞŒìKÀ[#6™µeP?¦MKL! …©›­ÐZÉu•åë‡8Ch ^‘ƒJå‚rK;6Ô£/7˜C»ÕÉ¿’·þÈ'0 ÂVY›þ c¦>›*oÖ¾°þ¼Çà ²Ëpš¨Çú’Ã"°8pwZ à´P,ãîÛ§} ºKÙ¿²§¶B9Í‹¿3-Ô`9·ªÃKn~Ól^g¶¡µ2"a;GQ" v2V6wœŠ*fX–/ÕvÃÉ«‘XÁYض÷­¤ž~g5ìý½þ³E™$¡Z [Õîœaé¸÷åÄëÀF‡Ö® …‹ëqÀ ‹øýÇ1µøyrj˜t ¼´Kƒo4ó–êÆ…Ôz‹†(ö•© ~°ö†`??í¾'ÎÂUV¦ÌDñ›þ°¤ó8ïL´´k¾ +°òì‹éXBU>IL¥¨yè¹QòµŽ¿ÿΚ̼"6çó€—ol”„X—^ws…Û¯€æïíÔC‡’3tRaÐô‡Ç¤VØ/’ÂVöØIkçg*(CÇR6†kNÔW¹¬­˜'Î\¼ä£Î@™1z“LLÕôïÉð,¸ˆ_7>{­‰ÃU¹ Vu8PǬîæšÉ«F­ñÖuˆÆ[\ÍÌ& ±cÝf^>ð© umzî-–Ñöw*‘Kë¬Ý/¸1çû,C•7Ž/ÞE±ü:š) )„;ÝF¹ éH? 8è³y–œãâ ÚD?àáÓ—Õ“£»¼õEg··u™+®uµ·SòÎÊj1Z"I †bai&+›XšXV fËxº§Êý\úþA\•2#,^þÕizÓç7Ž"[¨bœ3‰[÷Š± ´³¬ûç&{í±#NbØ‚»+‹…*fÃRSÀAñÓÚìíîÞøGÙÇþgn2Ë\¹™¦ 7pÞGëC©"Âæ³Á{§n7”2¯øÏl¹âsG:V6NB!ŸKµå *³#xÁ« Ö›PiŒ7¯»'\v%wú·¥[<ÍŒû£‰—ª¥Ñ|Ï.уϢ™ÌøVÐÂï7ÊP^š½ð“6eàí‰Uô´ª ôe¢:ž«ýpûÐBA±k+ü ‘óBó>:ê’]ÕÇ|ßo¡ÓäÆY´ÇMÁTY{Ÿ”×HÂ\·>ª¬'ŸÜ2úln=(Ùjê¢Åî~þ[ Ñ Î’jšÆ5/iCœ3ÆÖkq˜Y=†ëб;Utx _ Tr·§¸MVÝlYÈ’’PnÖY|* STp;KZ 9=Ô¬îÅ[•ÉÙR§Jê¹nœ“MzÛPÐÀØ–âóøV¡t·Ñë÷#wÓúDeWI€çu3ò×>sQ¼~!ZÆV°H…=”twô5šÌþÎçir Çúw+!íQä,Ÿv¢ö*Žq¯ªªš|`ðÏ’= ¿ÄúÒ†Nž¨ 8$46{,îôÓÝн¨¿ûÙ O1Á~žY_KV$%!ΘU¢–ª;†‡§Ta™Cp³ø;ŠÚŸÙt•,ãUð¾W;#,áÔÿ¼žMMâ)(æP ¬ÛÎô»`yÕùöèyó!ðöE»™W8p’Ýr2hA{øôJíW¦‘³Å™M'*Óêˆñ¨UŠ»È»Qœøj0®bÛEØÛ¾ÓbŸüÈž…jŽR¨™ŒÛšKËÙÇ@[iÝ‚RCO&ÓÄH(Œ}ß.õFýö ñƒ1|÷W†ÇûÓÎÊMa]3ÜKg¤¥Ê8¸‚·Ó¥c}ˆ³õ›¡5ãÁ·Ô®JƒT¼?nÇÖýmIe*¡R–i~q¦›¾G›'€Ñ‹«`j¿¤RyZý³aRí÷î íÙÍ„lœF)*G’I%>U¬­Kˆ‰Rz95èÕa˜Á?ŸOÑ©÷~Ñvp¿ÛÕYÃøÉ<êD¼ŸQ­:&ª9',Œ_;À35ÁUïñ:t»m^””3ò(}O’7å—ð ´Ã£GÞ)T–¼RØh>66Ѽšj'~=æ^8΃ eÇiB»ÇNˆüskJa_©|O2º%rEÚÉÖ-_3‹Ë?¤=8€ŸVÛ'3«j¤Í‡…8crS5FçïíQø3®œ‘Ö˜±,Îpº}Á¯— ×Aá°Õ|è)ƒ›¨¢8-.–'ì1«SßV ’Y)ô©¬{?|'xô˜Tn‚ÿ`ÝWð¾¤jªÕŽ‹ܘy$.çÞÖ쉳Dž"p²Àéœ!rˆïkʘi¸ZoŠÀj¼a¼b 8•ôé¥r)§ å’¼Ý$œD#}çãû²^Û(1/;‹µá=õ¥åË¡¼à‡Ëxã—ö¬×•/‚p~HÐÞ¼£Ÿ:Xø÷=L endstream endobj 255 0 obj << /Type /FontDescriptor /FontName /SOWZCQ+CMBX12 /Flags 4 /FontBBox [-53 -251 1139 750] /Ascent 694 /CapHeight 686 /Descent -194 /ItalicAngle 0 /StemV 109 /XHeight 444 /CharSet (/C/E/I/L/T/U/V/a/b/c/d/e/eight/five/four/g/i/k/l/m/n/nine/o/one/p/period/r/s/seven/six/t/three/two/u/x) /FontFile 254 0 R >> endobj 256 0 obj << /Length1 752 /Length2 1005 /Length3 0 /Length 1523 /Filter /FlateDecode >> stream xÚ­’iTSGÇ]àˆq©S´NªQ"’ H(`@–ˆ±PA@‰yxòò^ÎË Qq—V©U(z,›JQ\N]€¢T nU£"qa·îâ‚pëõxŠ_{æËÜ{ÿsïoþ3l–2ÜM†‹aSn®@  ¹€è=ŸÏ`³H¨¢PŸ¡¢ $1˜iÀ€Ðð=¥"w©È“Á„.™Dã(àÀéy™’¨Z……ŠJ€Zº‡Z…pBB*™ dÂzOèAÔC2 "\†@TMÅ0ż^&9®!€çû4bÐ},%AROC—>L !Ç’5 Þl‚ži–ÿ«ó †ÍVi{Û÷9õY]¥E±ä B«3P $Þ_:¾‡S@5hûWå” CÕ2<ƒÀMàÁå{¼Ï£ú Ô%J©€F…éa_âHÚ¿>Þ<¹"DàúáiûŠJŠSÉ:øŸÔ}±àSL›D¢FÍçòùZH¯»Ø~Ãq5 x<ŠÄ@E’ªdý‰èHL€â4h¤‰y\œ è#€vfÐ$£÷]ÅÀÓc*}Bošñù=üý £ÉÍ]Ü„"º/ßà xŠøËþ#THâTß_¡ÝøkPÚ@PÍ°ÖjïÕK²Ž­-J ,¸´×–£—]¸úüñ5G²½¹¼G_%K.FÀ¯ŸÛ¯±_‚î•ù8t?шš˜Çd)fS8oM½½y„#'o{øvõØ…ƒjsjª¿ÐîÜp×:¡MWâÚ~câËƤã¶gÝxæ3o´)º^÷æEjâò MÖa¿ ïd2bsÊgmƒóî5fœëyLÖݵN1Û_:¼µ2«o[oÈ–¤ç(_Ëöy=”Ï1jš/0;'X#•Ì —Ú_—› |åÃÊŽô-+ U<±k½Ì‘´²²‡[äiË2CæËçv:ïÍ­.rÆ|‚w3ÂCÕ ª´¾øÉum‡æ¤NéG›ŽØW¯þy—άjW›XÆ4ßÕk‡_’‹ëCÎy>ÓöÊz3+J•ðó]JæÒ0lzzö/¿æ”².ˆ”\[áX÷Ûú‰V!ã¾´[›•;M±Àõ÷Ró–˜@ãIÔ)üÛæü§NU¥ï. ˆnˆ«ˆ¸îZ[|ôDÁ ‡âu6±æÒ  ‚I¥vD}«¿Ë×aœ÷—£d1m a“õ¤Å˜ñ(¡2e´¨§{ü>©x§åµ÷‹™sÍ% ÅãSmï¬rNÜÄ}1ÕäõdðñÐâ¸äK^ŇÍgÆLÉB"RÜæd%î+ -Z«M~&ºm¯äÐSÁàÜ”ÊYéiM™º„.9•SÃ^t¶ø5*Cù*?ŽKFùUTUã$Þv Û”$¬øn‘È;&þ­Å·0l×nÓæåíÏ®{Œß°ˆ!Ö\ß*aê—f¦¾[ÝYlfXz>ÚŠßÝ›}ûL*i]U¹ËÞ0Ñ'rÿdß*æÁ-]Óç¸ í5&>åºq`s)Ë×;²ǶZU¼‹u¬Yáð§¼c,n.Ó¥¯ ¢Ø{Þ.ÈœÇKm«Ÿ~DÌ¢fuåKñðÉòcØÔƒnÛt½ÈÛö’\¹óJˆçÑÜMˆß­<å‚μŸÆË=†go¼p³Ü]¡Q¼‹ßç¤IÚWâ\9òNâ¬S[NÀ)ÊoR®iSêzìv‰ ©~¤wÍÙ[ç²ö¬Š]on,Oòj#®ü|·îÜùŽÍXáå…Á2eùvùž–ü5MÛgÇv×^µœî8¦ðïÈiPzñ”U1Ì)Yú“ÝŠLeQŸ:mC»I‚U;h\QÓÒÚ8ÄÙçi“;ÑÒe^~o]Õ„á;m»[ŸœFËÛË:¡ÅÂ+¼{6Ì6(Ê9f z¤sRg»(7ëpš›Ló\²òfÝ®­Z8|3 ¨t,^QgéðsÒ:J³ÊG•æqã¾?<õBäR¯Ÿn4ÿ àŸäQ endstream endobj 257 0 obj << /Type /FontDescriptor /FontName /VIMHMC+CMMI10 /Flags 4 /FontBBox [-32 -250 1048 750] /Ascent 694 /CapHeight 683 /Descent -194 /ItalicAngle -14 /StemV 72 /XHeight 431 /CharSet (/slash) /FontFile 256 0 R >> endobj 258 0 obj << /Length1 2058 /Length2 15478 /Length3 0 /Length 16593 /Filter /FlateDecode >> stream xÚ­·ct¥ß²öÛF'YI:¶“ŽÍŽÕaǶm»cÛ¶mulÛ¶ßü÷>gwïó|}ÇÊXcýjÖ¬ºfUÍû!!”U á×·Ò5±²´§a eøü.Ï@` ¥§€!!´5б7±²Ò±7ø`àà`ˆè~þøüûÆÂü…† heíbkbdl ¤ølj Àoa`k¢§c ø®col`ñCOÇ `¥gb`ïB à77Èÿ³Ã o`g`ëh O ÃÀÐ7ѳè™XÂÐý#IÜÒÐ Àöo³¾ƒõÿ.9ØÚ}ŠÿK&àS¤¾•¥¹ @ßÀ†NÚê3›Á§–ÿ?dýßà"ææÒ:ÿ„ÿ§PÿϲŽ…‰¹Ëÿ8XYX;Øؾ[éØZþ_Wƒkûn oâ`ñWÅíuÌMôø-Ì ôÿ6™Ø‰˜8èËšØë uÌí þe7°Ôÿ¿">+÷/ tr’ B?¨þÝÓ­Éê˜XÚ+ºXÿ'ê?Îÿb†?üY[g€:ýgy>??ÿûKóÿä¶Ô³Ò7±40²°tlmu\`>§ç“Xn K}g€ó§`:ZK+ûÏ-€Ïšx ­laþi(+ €ŽÿÓ¿‰@'ð‡Øt‚ˆ@'ô‡8tÂÿ!6zÈbЉþ!FØbЉÿ!fÄúÔ"ù‡>µHý¡O-ßÿЧé?ô©Eæ?Äþ©Eö}j‘ûCŸZäÿЧ…?ô©Eñ}jQúCŸZ”ÿЧ•?ô©Eõ}jùñúœx:ÿÐ祥ÓÑûœÈ?UüÌ©cÿÇý3”îút×û1~ºê}Nª¹ùŸ€,ŸþzVæŸñ-ÌÿxYYXü•”þ³úágAþøœº_ƒÿ8ü“ÈÀB_ÇÎø?6¦ÏB}ιŽÅ_q>Kiø?£þ…Ìÿ É_A?ù²0ýƒŽd0üc0ÿ³þ»•ƒí_Ù>ŒþÂÏøä1öÊØÅÚØÀò/OÛ_ùé?Ïiú~öÅì/ü¬£ù_øYø¿NúyséþDfùÜjibù—öÎnõGÌçf«ÿZþ<ŒõŸåÏ`Ö:¶–憊ÎÌð?VÛÿêó§jëϦ՟þ1ÂÚÜÁî¯øŸ›?õ9ØýóÎø3IŒÿ­ì ôuÍÿ+/óŸ…ÿNÍÄñ?+ÿmfø§³õ…á³Ì´°|n²3°0ùï™dùÇÇÀñ¯î°|±û|¾ýçPŸ5µ3ÿ{â>þ'-Ëg}ìm þÜÏ:Ú;Yýµá3†Ã_øÙRÇ¿ðS™Ó_ãø¹Ûù/ü ïò~–Ëõ¸ÏH®¶ÿNõÿ>笜Ýh?~~ÑÿsÝ8¬ÿå©ç`ûÙ\û½F?_ÿˆ&Ÿ/g=˜¥y+=NÓĆÀbOáÜÉpJ`£ÆhéÚ®™vX¿Å`ó‚IÊõÕçÒT„}ð}§W\»Ð6w¹q‘ ›è¤¹÷}ÇŸû)®Í¸ª×)ß]ö¬‰üN[foOY€e¦×G‹ã~äõ§_œdË’ )@®u«;Öu§ú³²©Š¤˜+Ô2Ê#%Ù3­9!Åý[›ðó4 ‚j¢Z¹²js@yÎ…ÊŠ}×x@BÖk#`’ߦD“?à=-Ê BB¬þèªäK)ØöÁ—¡äGÄý2P+Ó]q„µ§.1 w¼ nnS%|#aÕ\/ØÕf¢Ò6ΓX̧¿ü•kUAöåú~ HxäÈi“Œõúºé}áŽkŸ¡¬A¡NßlJŒ©ÖŸ’:‰æÊ€p›¦„Ãï CdÍ÷áæÀ—¢ÉïQ`c²ƒôl*@ñê)£ ‹Ø7À%{”™Q/%Ù'iK‡Éwµ%éB[¹©¡&;.üýuú»"ˆ{' ʲ˜Þ:Ÿ|a¹BŽ§Ï®Oœ³ÿoC\qtÞì Ê@87¥@zîý ˆ"iaLGÇýÖ:Ê”¯emb¥Û4­ÜÆ˶§]5»wŽ%ˆGŽÅ†á`"5XxüX RAsCƒƒ°#?ØyêõÀ ®ñ†ÛlC??Ú × ¾yå¼X\êV7@¤S°U&­þ€1Y`Ìö³ÐÓ ï2;$³³¦ØkQ¥o> åûÚËh:}##Z/ÊQLRn˜ü0…y,%q*Ä×iQ”¼þƨ˒ ¡§ïBèvmr:äJõ%¼ÜܹaO§ 2±ƒjp„±NÏá^÷èÇÔ=‹Q†¼—Œ°•“$åãûÍâ']Xò;¢]‹Pízª(~î`ö¸37OÄï=€Cª©”áö"ÂÃ` Y9ÄÞóôä«ïðÉìb4í.Œ#foEÙ¨ûo †t§‹ÆMX¹è¨§öðÈ·öÛIU!içˆãd÷páhZ#lI·ÜqØ[Å×ØY=éô\=#þVÄtVµ–B[ÓÎ&’Q-Âôus•Q!› ø,ÍÑ@Ú/³7¡ ¤)!“³X4É/©Ó4v.òºïÇï C…„=³¦YpHƸʼnðÐWÇ2ÙÊf Û„Â9˧z÷_2§üg’„ijŸ’z±ŠÞY'ç@°òH9@[x ?øéLyÛ)ŒÒvɾMnŽ/Ë)ôt>æ™ =qHˆÏp<èÝòãpQ0™ŽUa[«Ý…T9³é*"¿³–jÚKû°Å@„@ª÷!û+†ydEGî« ú Ê¿¶êäe±—ú¸‹6ÙÅèà:ý #1(æ$Ë·ëÒd=^¼v¯ŒeC,n"¬7ÑõÎצn@vÓ§à©@Èϼ³š„tâÊÕ|Àå&×ç"!„ûMrã*?¿—V¹”>µïY.,…*òýþCs–˜ÃÅu¯BÄÚ_ ± ˜Ãòk€U²æÍ’”\Ýúݲð(Á çë°¨ù))omøGÃôú[s““ŒÜ1Š°Oc`îÜ»þ×ê$Û ÷•¡%ùææèf™¼‚yÜáé‘Téøê–,C0^¡©JÆ;áæ-b´Â7¯#+ÐŒ9ò!¤Î;‘’¶Ÿéw^[érŒÒŒñ:N}lØ_Lp3a Ÿý[nV[óYÇm`¼ñÆ¥üºhM²ù¶ò&ž9‰“®ñÖμ®$£ò ñ·àåÙ] g›¯ÌÈ/? ”ùmžmF¾råÔåàï)ÿš rùeŸ?Qá?”ëz>‘6ˆÃèÞÀ…Iÿlœl³e?É¢jÇlÙ!ÝVÁ#C΃0*æU‡¸H ¡Öo¾ošîÏ×_û  µ|ºŸÄ‚êñÝññ$Ÿ#éÎó‚dpg©˜°seÞܱÒ#”Óå¹x™BïMÔ8C.³•Ê)ö·Å¦„Æ绹3.¿h_]MsÆ ?9lU*7ºt#œ$?jÞYÛó¾'…/¬¼éÛ,ͧìôŸ¨ì"ngÑ ?È &¿,x"¥´èugn‘BÈapô/ÍÉS{›Ð|)²ßrKsøv~ņµÆšU3“®%ã¨c/ðíÈvT'ÙÑT3‹äɘ&ƒ’ËÑ «jÎûµ¢Ý¢MÆo*}dHBÇ îgJ5-€øÊa?Ÿ ›RLŒ×ŠŽ”äôÃ2P7Ví \¬Y¸OÓ†qÇYp_f`£Ž»z¬¿ÊTf.ëÆt)Œ ¬XF…KÒq£ÌP›ÊEJ?ß›(wuž$¦hÞ Hîwo«2Æ|Îy5&î\;Êe2ûy]ÜúÔåÓ|=/þqÊŠ¢•Dû;øöœ'ñ4›„ôl}·û{ßµú@† ’ÅB·ñ¦°G¨î¤WèÍHYðàú†|~JÞPî?m2CQœÖZ§U‰Ëé/~þ”üHÛUìâGδSЦ}™­fq˷䎶„7>T4çÀrS>5*ø¾Õ'PD, hœjd6IIo|æ97;<‚ÅQ¶@Ÿíbª|…®ÎaÝ‘@ÇŒÊl‹L¾ÑŒ˜•®þ´ÛÏo±\¨3¼½aÚx4ëPš <…‡³°pØÏd”?•7bQªG¥AcX”çPrÒE8µ°“åóä)z`Xù>]E.Ô6pvwÚê!ó¬ñ>æÍlps±ŸÇÛó;=!-¨Ã¶M3¾4¥¥-üyÕ,¯Wy3[e¼×Âaf„€¦žñ²Ù÷¤'¸ì¨ÿ÷S±,ZcKæ|®÷õ} Q©Ã…9§àõKY×OR×:)KÇ㢥¦É¨_ ˜æºa†”P‡µtÉ~?ÜÊxº;…ý“‚èŠk–mânSäqB§Œâ=¸á_­p;³ÚýY©T¢qµñå¡»ƒÍEšÇð¶îã±M`®Dhq‚ÄúåãˆÖ’Š]— ¡¢-%¹ à–ÏÞýj àPlÛÅ¥±ÝaåeKE¤òm)9oÙi@yQÛ2‚¹×Û… ]0r9€›H¥óyÆÞïÞ%X ÈW•JnEô¼?)¾ß'Vp»‘*Œª†7¶O›žÅL+çb €64¥­GjæçÇ[y¥Ò´å_ruÁ!-¸‘ö¡pkŽ™…*¬·¨¢ŽVÛ!JÅ0×R$7/„äT ð8$Æ›Úâ9 _0¸nJJIÔko5Ml÷‡ž6wŸNk8ÊÊfU·»þž1Ã’;IÐÒ†2UZƒÑÊY¸7tx–¸QT¦É²Ì½ d&‰—ËdËu㘠ÙÃËN–è‘giVK íÁÚ ëÜ0µ…}ú5~‰à8Ò¨ÀÌQ›p7PDœº™:·*<\:2¼š¦NkVzÒr€N ªé¥µ:ü1Æ.Z2Â8¨Ç2hñ샋€!¾J4ƒø›ýCUq§Ù¼¥ƒxÁ‰|ΣgµP¨{i°§Ÿ/?«ò¹vYÈÎÑF!.Œ~ëyW3ØÞ/×Î)f=ÂÌ:È"†ä>Â׳£åöy@ÌB!ÕíÛ€)}WÎÚÁÛêô ~€ÇQ©­,ä¼ÓT§o†øG¾¸¹RQó•Ú?np ê¤öU¸ôzÿ¾é\¬¤öVEDõrH˜™& Ž™]^í³]Êÿ„‘ŠúàüW{ð&³l( ñŽ:‡(!×t•ïÙÑ…†?ß_$]~þ*8õ>Ê&ºáò@\«ï™ý*¹v3 NeÆ(w´¡ózámyíê 5ñ¡–elí¹“–a&«kÒ‚jªW»¨É?2üår…0;½¨÷wo^ÁÚú¢9kו"ýFIó&#SYÛö~Ì2H åõø¯áê!Œ],-ñ `¿ÑgrfëW3[»ü3ÎdÌ`«¢ÐyOä ÊpäŸðÌ#–&a~?³Ÿü’­®;*f»{ÁcÂZ輑÷ =):œŠBµ5Ulƒ1ÍW‡³/åáÂC–~Îj5$ÂâOqì’ H5nÛDƒ*í /–ZÎÌPôæòÄ®[7†ûØ0{·]6î2„ë›0½|!fÏò@Nê#÷¥ÇŠÕÝÀmhÁŽ_H2@¡õ3Ž9Ýš¬!xdy‡E¡NXn°7óƒúÌ›‚1€}™F ÎúHÕ†°(Ö ìoâ~[ì¢,o½¿yû<±æÁožMšËµ¸HGŒ£øŠ-ëø¸ôÌ5‘Z6°Í1XÄÙšº·êׯñ=×Ç¥ûسiÜ!KjvédÆppÖtŸµ ÄÆûÔÔ‘¸ñ¸z°>‡n¿e?س‡ìEÃHn5xÏ•_¼±7Å!„õ=L«ø$ìˆBd%¨k@ 'È &®ô½a¸DR]º¬®ÙF仌ö }p1aP8ywÍ¥\IûyCñm¡ìج c©W‡—p~•GÅ1oqf¾ŠSp;Jš8ÛÚâØ6묥Þ'v˜ÃܹD®‰3Úd!S H¸ M5€ ¥6ü·«†åÏŸ•4Hç•]Ñ© L§†‡ü}ÀÕ/rº•‘˜% œ&A¿ëb™ K»1lCóÎó<| —èf{4aq3ŸÓ¶×o{$½à¥Ãi5àïNd"jž$Ìãcô4¤Í¤ð´§•!ŽãÌ£N—S2ûñÙ1}ý9» ¹¡¯>ÐfûyÕr'AÊ,m.,9Ô1‡ÞËÖ±±ùä®×Ä2ÆÕ¤ou°såג˽ßwʺïvkA÷]±¬%ÚmËE{â$d²y¼ÂÅ‹2õEšÉì›ýZµìÕ„AÊ[Ž- ¥ƒ¦í|8}„S¢ÚµK–ml¿#âÞŽ Â5­fÀqùv^j÷!1f°=JÿÉi€ÉY凩v`D},©Q€ ÊرDOš¹ò‹Û¨Épv‹Ã…ö‡•Û0k’nvV:n瘉T’¬K[üi~ì,è¼ÜØ“ŒÜýì¬--Qbí8³æfs ¿ïK'?Ð2µN°ÜýBÈ¡N+‘åOÒKàRxVßÁ\Oã?GHpsäU‡Ú×8&E¾'òlIb»,¨Í& \ýØ|ؽçæj ÐbrÒ Àp{ÍNMèUV°€ôˆWdR6º;DºŸ"ßɬ2¼u¾ðl°T>9×-FÙüøÊÜwr*úP®29´¼ÊÅ :•]ð^O©]t í?éÍCÂ5¹œØÏê;²ÒsÈÖ~èp>…*¢©ö%’³* ª¬Ó­RbffˆÀˆF·;öž!¬68:ã¼—EK¼àÚzdhj°Hµìi‡Úœ8˜æ°_N—pCàÛë–­~¤`#sàÏóí˜ kœ2ZóO>DÈŠ®^oaúèùÛ•ég1ë<:‚7N7*VÒ»èhãÜ^­Ä`žr­a%]æ§'`ƒMT‡ÔÔmw°z©fµ‰Î*íØÙB37j¿Äê•23—&ß²“%/*cÕ²cÒ€òÀðäjr`Pl¯Ö1gÛ\Œk穯‚ÚHüÛí¸¡q0Æ®Ô~ò_Ü`DÔ¬jŒ+)¿…ýtËM‡Rk93Y}Ç¢“î»GÿrJèù›ü ûéÀÀ̤D¿ì8­i‰fÒn¶p×WŸž*!Ng!Tñ«•&¿p> îtDEè2£º€«ééõ•6ç| µ±#“i´e—íüÏ>àX=ÎÈ&&õÐVs;6£Ù¯ud¼ÎÇZå\Ø/‘%Õ$¡/5rô0 ×c—‰îóJ«‚£ø 5~‘¢3Øn®=¾ä0Q¤‹ä8 I“ Àê6¡:3v{j£°¯á£!«²Ä’Ä„ÄÈŽóžmŠƒøŠö:CÓY)]ȇÜ^º;7¿ÅVH}El§'ÕsD"`;³™ä\¼?Þ.ÍCRË‚2–Xmäî L}¸©¾è£ËÚç4µÞsß½èÃ]X#³É‡ ×4RÂZŠÆAÈ)[áJóùVìl~¨'ÌW­I7…{Á tbˆ© L¬]óñÍÊ·Ù×Õ»M«7Ú~¿†ÛOÉ/\ßWÜôŒIá‰é^áUú†úà”ÑÕl)ÁA ØY½¨éöu‘2߀|@Ë/…ö$&à‚Ç…t»8äy2n¥~ "> ZZºR…®lSlÉ3â¤o†là§è~,ÅœùÍY‚ÐV†µËá‹4Ý;_w$1sLŠ¦«Á’T__Rzpà©LžtÂóî†K‚ᆡ৖§Ê|ä²ÉÖ‡ *Ÿ->6»Ò=›¼ã¾–ù“úÀªWìdãq‚"©Î¯`(q.9~]FK¹Å*5%Åå5€W9…è—4¹žïêö‰ ®ñ¤¶>¸U«ïáÉÜ6=á,É.Ô%Sø¨·+¦Íã"¦ìàÀ¹F È™Ò14Ðõ!¤µ¯6]b+æèË”5sX†aßðV,OÁ]¡Õ$rÀéÒâ-ï&¹R %B=6þåÙ°Ê7…aørJ WCy}ŸJä/Âí*¼Å“Ìljáa!iŒ™ÌoÄ?õ¤K KA3¾¢ÿ´GîaÆæìß_»<+s;Û£Œ-Ée¬ßåï-(Õ`¡ÜGŠX`¶YÅ9 LÖZ5!(îº)v|Ý@‹ørÌ£9‘-€T‘L|‡Oå !–[×Jóã>Í %7k\œ‡w0™ûæ±^Ú÷ O¢~¤IÞÔ¦*{Œñ1xBrϹ”P‡ÿÕJÇÚÒ¶sK¶·oëŒ'õ\~mNÌ»BJuø4нé!òš­­¹:þrõÕeúý.qIX tZíp1wS¿ÐB‰¾éðQe˜ÓG®DíŠ#bŹonîòê;$Ì×æ­ ÚßéF9šŠí­UÛÀŽ-Ю¶´_ ±éÝ“M6¼ GüujÂáv_Åø@Ë¿¹æTäõbjb`gˆ{º(©YhñÀ¿­ò=¨ÈôH‹Œ«ô¾eo<'¿yâu¹èB‚ùDÏYÏþB˜eàKë–‘f9F…ERöÁ³a¶Ò$æT•¹$Õjkp¿z^*÷ŊΗ£® g£pþv›Gzó6 ¯rxÉSŸãŽ&ÙCkÕâŸñ!æêÒÔEU¬VÏ¥*wå;áˆ_0å"4§oᙫ—(„÷ÍŸ¾¾]ú)¬!ì Í×·iË£!V³¸ó„Üí$¤¶À,úðW+et}©ñ*ù#éátÇ% „\ÃPløò˜ßÖËÓ:ž(ë8¢aÄmô²ËÛéc‹™ã ——ž_ðgW·»1|j¹›W~g}‘¬öÇleiWê‚p>ßêeˆ~/P nÖ¡#¥ôÝFYøt’cž5÷û ÑZ ѦÊÅL"쯛Çûvò-̱œ(&ajwðÉíM±D—UC8 á±z¥ñƒs!Út× zò; 'šBiQ¦£RI¤Ð °ÃDsq¢ÔŠ9‚ølô'x‚k8Ð'*öѳð^}àk²#Ù&-—ƒï–` Üãse…²7Üòµ ·LxäfÛÓR^å›_¢m(`<'"Ï› ~n/Ÿ ›µ©_©ÿ>~ÿP´[•Ú†Ü.jb^¡²;–U”¿p@µ º¶Ø©hZíÂɯ-ˆöÚN¹ÄÖ :ëôŸKB_û8|gyr?†ÐrìÍæv»\„`åÛšÇ\H™µûÑ£ñƒHø—ÂEÒ6 ˆJÏ#Éê¹Áá&Œ°oEp"e´0!­'´ßm…^̈Òïô«F¯C’ÁŒ÷©…0›ˆ¨xÅþ‡ÌB\Ƚ;).ÃÀs "!ô ö g)”¯98ZÝ@1Ugùû+nøu•:üžq,Òó4h›‹ÄôIKã†5ýîu™º¤ÄP}ªD»±ï²O·®Dȵó‹ûC‰Œq(†¤y¼Sîp®7hEüȇõĺñ•ÈW^7Ÿ<ܽõôp¢œOV¹Á¬%³]#³ðâPSÅî@"(ÕÅm$ä7HÖu¶$×¼t¶eä Â@M@A 7™ãh<Å‹ßËsL&â<˜E·áξü²Ïe…¨¤†¥Mýöоüí5³œb"²èRŽmßi1)T·±lÚs´QTçõ ¨x'G&ìuKë:Ÿ™ÂŠ…ÒFÄHÛ#ÏEâùUìq !•Ì)lôµF·Ï$´UnߥÔã¯=(cÆØ]·ïàqI½8ås!¨sU)ì€Òðž—A­>`5'ù¶õ*Ÿ¢ÔýS;:ˆÆf75§ ^FïÆK¥¯¿Jóù[1§Æ±Þ½Ø?ž& ¼@÷¤q[ôÅÛM@¡ïˆ­îHõ·7& ÷.›Ò'}éX^gâo^f‰ÕGÞ¦êÅEïàR)à! ð÷}侃”ÀÉ5°—ȧ"¶Ý“v+VßùlüŸ!{¥w[À¼ËpüfP3Ogx+óZà'W#làŒ S0’qËwóCrµœG´Çݺp’§ØéCRÏÏ‘o¾«ÃË)š3Òn?[lZùHÓS*µM7¨²y†©$²Å›AÙèÕ^9 ²vösû`7¤Þ/cŠõ€ Š—âŠã:•šÝO#$+|ÝQliF¼²!RÜí !›%ˆF+<²ée—eùíD?¦^Ì3°(G¾ñ²‡ ÿøQ [Q3Á+ˆhßÒ#qßÒ¯åÛý›¢l…ùp—Ž¦~^1Æ”@pŠªŒµË®€_ÍÖWÝ5ÐvŽðœVà7j«…Ö¾ÓÒµ¦«ÓU7ªzwK[¾‹ˆ^tTüÓýÙÛú™óÚ|Œ†ÌŸ{§ðÑxÌj ’ë!¯jUpŒ¿¨TbA?8“_²\Cw%t›@l Ó!ªâ–C»c˜`p°è£ ü²¾þŒqZ´ƒ!€›É61nðˆ­KÌø¶µ^q¼žb–üRaÙ¢uOeÄ;ø`­$®Ë¦K‰Êðà_¬£®ìQH⧻§›E¡t ±÷Óõ“|‰^YòÔ ñŽHB{xŕdz’ttâþÚÑœQ„UÚ OQðá3úAãŠ0TŸe‚~GžY‡ûtRªUîÝv.¥å䱫åG ;¿ÅÎÕ7®ZÆjÊ€ýæ•êcT•} à7EC¿CPÛ /g‡'‘þu©ƒ*dÖ>ìY™¿RИˆ©L…38c†ˆ{nš®ø(Aµ¹ƒÉáçä¹m¡]×\jÔÙ½([õú)FL}ê™Ûé;²©S~8SÖølŠÒéwΛA\™ž»a`’Ýf7‚Œ¥ªƒXX£‚Î-îßÒµ¥î7-ùð¨qñqué2¿ËQ*ÆD»Z·jÒßÌ%õ‰2¦§œúc«õˆ²K¯]5E™(Cúë8H©—°1òÜ3Ÿ‚Œ[/‹Á‡n Û÷\÷ù—Ø… ÎR-C"òÊjš)w¶V´`ÁæɽþsâU’§r ózeÙ29Dùy\ Ñ¿Ð † .‰F(©Áæž­ ÕHበráé•«Æc…½拾‚ç‘š6)ÔÏ+éÍGÏüRص<Ý'; º÷Ÿ…b«°Ñˆ<Ê_JN…+¼L^òxúúóê¤ðî‡ }qFìç@%;9ŠOÀ›¹ÛÐRYŠËEe<ÐkÚ^ °÷7ú‘ðÜÎpÙæ¡K%ìV”äK·ü¬·š%³m8Þ¿––9ð›—²5^~Ÿ?Þ¿_ÞÒ)'C Ba…QÉŒfÿn)CÞy——‰¸¥WÇÖ%¦ðVÝ—,žl„.–ïl9éÇ™ýÖ®ô#Gã}ÛÔÕäìt»s¾•¦ç&e\ÁŠ[œTqà>—[w­"ç1MÄJU™(Ólæ*)€à\-þÅvK¤ßyMš¯|a;F“s¿"O ¬;%‘~aMOdÚý6\vz æÃ"@NÌ­Ç)/éþˆß¡ê&bmWKMt”Ç]º0(f© ps·ŠÇ‰ËºÂÏÀaÑîæPÕ›MË7‹šVÒ*£•Ÿ§Ð".f, ˆ·~V»_WI J ¿o•e¡6“,•yúXt«­rÉSùùÇ|SÎcj(‰}0¾v·ÑþÙŒ?¥8Â¥èÍâErŸ µR(!˜FKŽ¸’¶m'–(ïâ“ón)[lÃ*J݈F|—ÊÜP€Fsŧ.z Àî§f.Ûž\ É;Ð1Ñ"FSH/Hî0>["¢‰tû}&`ò)i`(ÏI8B8j¹Ê4±HÿŠœtŠ‹‰LÂäË9Ž@á»6G 1íìׇûÚ¹«šV©×Ýf{ëýð,.USס€Qc¯IÄÓ'„…Ç))¥Øun—«=d‘º$†h‚Ëw 0ñM…©„¬¨'¯É–~'htÅÍnŽžÔPáy Κ#ô«D嘘8f&iÄÓ…ØŸ&G¼§×bO[R½ÓÓZjj3 _½©! u]%(×…FN0sMàT‚ÖíL±>Xã݈¹Õ`A-KUÔ¬)§›Ý£÷žáâÆW§ÈÁØŸÁÆÒÈá|Ãû·€'\D¹ÏOVÖÑ_G’û”À '•Û¸[X%^ÞÄÌ$7íîù Õ$ |õ„²d%Y FÙ˾—.;¡øò“ÃuS€¦8j~Ô]“ Eà¢QFß#b°"£+I5«ÊsE²¯œ°sÚ,V€—{˜ ò~µsXæÑ[Ýüétò¤c¦ì~h¨Ä»GP-âm[ ª‡nà墴ŽVW!ký•tRœ¿&‚ÌL¸^€µ ¸YÜX&}‹ÐጂÐ:­µ–Šïáy“ÌØ"A5ªs}}:ôZ¦¤‡àÕ—â6Þ$ñcŒ†ªOLÇ!™øȦ*[«ô~‚ ïÖN܈ŬVŠæçò‰f»ÂþÚòzÛjK‡&†pÂðe€·}¡ɯoûÜ®ýc‡Ú$T{¸ ìmÛ·¬ôu4É\ŸÅÿ`Â×ÉUê+ÁÌø%M)¨ÿ‡EtOà¨ÏtY' íó¿šRPC‚WŽ °PâWsç/ÝHÀW[µªƒ½ã¨qˆç†}G?Á¡ú¢¿p†|cÎ5vúª€õ…¢IJÏ…1@€¼öž©݉0×ո攲q9ÉpøºDQ·5¹-⵪bC#Zu.ùM•F.šqúìn$Èík ê¦RmRäñ*J¾ù-Ï ¾¯Û±Yœš«ƒòK÷.?xªA=ž‚ùÁ!^j˜1yãèã­tÀ˜”®•·çë‘àا©'ô3¥~—S¤JÖ±5ÈùN#•‘_oÒJçë ùâÇ5!¶T¹µÔ\oÎ ƒs?Òs h®‚4ì«×Íí‘niçßšõs)ŽÚ^ +?J@jÕ嶢xº£Ú9ÀÞ>€kâJ"ˉS·ðkùÚ³ïnpº6¤p€XN¡ò ŒÁ@@ãƒj{¿è‹™¤o)†Ó•Aé÷mŽ¿Pt€æW~ñü¥ž /Ÿ.Ý–éKŠç¨- (ñ³Š° _#´âQ 7³®Ü³váëEý ë.—Ïù8¸¥ êSN,ñ›¢â l“Î¥ÇÙç U&½Ô7E ´ˆmÅpN¨ÊP‰Ãm©0w)‹üÔ : Aô{Ê¡IH|ÂHÄÒ-Ó34¯Èá”Ï€´8–¿¡£¡—Ø_¼·£ÂìX:dmð~ˆ´ü ×E#ÛÁRú©v/dµ®] þŽøLµÿ)På +ÓþYo Wßùœvô]ü¸˜™I¹‡ÇëÊh ' Áæä8J³¥0S,©q®ª Z—¥_-‘l’/ù¦ˆ![³+~ãô¤^¨þ¥߇縔¨žó*;3ÁöM|Ž10R±çf5 Xˆdr5 àÖ„­ŠDmÜËnÁÎnhRtÿÊ“å­äÁoÓ 2d|+£ÅdÕ»?FMžñ—˜ l¡;¶ÛM—7üô¶“òaFT>´3ˆø;¤œX¬›²y…Uô‚Ê×t²·l_mÑ3MsäÒ &WβKkÌ>¯ø.ˆ4ÒÈé‡w”’UYVÕ‚d^nÞ¡»Æ †i_¦X}vIíòÒ­/¬é'û%‡ÁÔŒÓBú¥!å~¤6ïµP¤ýû{‘|ÜŽM¥äZ?ˆ´h¤Œ†Žè[è/ygÂdæÅ1<P±BkyÊÖ;mç›î°õøæÍ"ýøÔ¾†&ω:'Ðkõ`á™ÅCU\=™êi¤H=÷ì›ÞCÄ5sñ'VㆯÅâç|ðê€ÎÞÓcêTµK¡å £é3ËΞզg¿îò*D†èÆÒš’zƒúy†ÄùÓf îd½‘£)ëð”6꤮ȧ”·®X=ì†ÛªÙ™ê¡^VNây@&q4ÅKŽ¼]7Ç—™-Ó¼+~¿)‹ Ù+Vªk!ÛÙÊ\ůæJôaU)î`ÅS¥ œ<.I‰‚ËÛ—4úCݱWý US5¿«8Æ"Ém ݇zN%0  ´vkú?Dû¿ü $Dqîù2ƒ¿ Á*§PB, ]礉4`WO û+U\§ñ«‰=Ú)|n#"”sѹq0ŽŒm|2‡E,ƒñÌkl]ñr{cM@<@¡u ˆ(’þ{øK}\f‹_—ëKm­ðû¦Óf(Ès_Ü ä.^q÷­sa±Žˆ".šþÜ*FU2º‹ì9j/0¹ŠbØ››Â¬£bëï SÝÜ`MM_ÔFf±SG6üj«ØägWFr¯J2HȑξÁ2ù-Äþ1¯q’Ý(šr+„€5HÑØ éx7ô |Çq‰‘š=sïEAKéÅ¢åpa­ˆs!áÂð€m"øÏ}²ì!bAôŽËÁ°ò‡\ÄãG¦˜£{blÆjiXqY™!×fR»AüS}‡TD°ŽÌå,9(WPtÏ|Ξq³[RdW¹°žþ×d<:æì:¡ï½òló˜÷÷㻯q¢ðJ¢Xü¿šÒ@|c¦'x†vÞø­> Ðñ™à”ÐĘ·«¶ž½Šqõ€[Xs%¢´ÄÞ†’W™1©@šÃF*m©÷FµåXåõršå6&äæg8˜'©9hÈ´€É‡ÒqzÒ[ìYR7¾cjŽ»$̬L,+Ü£ÏX—ïöÃàjlOP›öèYšÊ®~0=:c€•GôÐÍQ‚^]KIzo)¢"°{Ólß`¤pìÇòg³•ÍL{ÏþBÐDNÕgän>¼'ôVBK|‘r¦›jô¯Tý¡ØjtüSX—@–ÑÛ߯™„ܧ¯MIû¥Úîœå<æöÇÑB.FÀ÷· XÃy³åèÛoð6‡–óZj:ý•†eo³Í2+?4Råª~B`ïãɶN‡¼¾¾¡|\˧çOžI…ÂJâ± v©¨?vƒº!4¬7Ég’ 0O_™3͸,¦8IvŸ˜?(±6ïc!½ åÀžçÈÌøÑû³3á»ü÷7΃˸s`ùo]±ï• Ôþ˽z‡|R\à7ªìvå™ ¡‹l DêîØéRæÖ¼Á/šM©ßê¨/ÅÄ¢8¼uì;øÌkâŽècý„¡ÅL(’c0ï!©U˜ª?–ãû hÌýP|’£ÊT²ŠH pÓ/]÷H\’W"‚öÄDK¾Ùj0/ÁÜ°“ùb¼µˆ]ãHÊuIÉ529o²qNíá…¢ ³p$òÚK<ˆG~YkŠ„*â—MU™eŠtUªók#Çÿa©ÏáL9Ç"º[egÙm‚~ôyiÈßȽË9%9Ó'ÁÒ‰m_ üJu™ý5w@ïºpÇ’«õ Œºåâ‹óˆ %åªÏbÑ;)v3D¹›ï*ÞzW˜I 9w£ ë.+›wV[_‰¢ô—)R’k‚«.¼‡'Aö&ƒ†¨é{:  wÀ¿äÛÕjË'=œJË w\ 6 ºÖK.JÄ}‰†Î^ÂW±7àŒaM"˜3´QkÕÜMs`~5Z:à=‚ÆÑ7ÙAvîï{X§G•?8?ZB›3Íß×™¸«Ò°—ì%æ诙Àø½~Ð<ÔÐ92¹ð¼"J‡qaeÔ™§í|idÅñënÞçQe› RLjì{R þ-]†£QÈlpåi†0òÔ©—‹Ü¯P‹ñ™Ž/Ü»|›8–F°Ãšñ¸ ˆ^ùþùqi2Ø&AodæE…~é‹• (gu :áÄz'‰N^R(Z„Â[×Vô hÂ3‹ðØÄñ—Lðaª8F$;{üüZ°P DÑžá|¦º`ÊŠ¾ÄCÄi DèÁ|>WZѵP‰ô3|ÍêL­º,9ÙßYÏñ>Ê`&(¢Nç+–ßšSïsthjÜ 3â,„CÚ—m%ž¥4;¡%…$Bïc¤ÀMÛÁáÅç€#µ¼E¡½>LÖíN§¥Cã*0DÕ'bÆi)Ù€R¸ÑäNçáX,˯ïÉ,°”?³­)†%Žê"Ï mó‰ÿy®ÛËs•‡ua‘è&ðõº€R¿÷Dwú•Çé—.£WP­âø¢Ö-ük›škÜ Àá·Í• ØO‘¾+þ%ÙïI™N VsSÈdó’²à=Ìá‘[¨Õ}œá)% !däŽKDŽ¿¬bxÉ]§ê!|qxeJü:´~— 1á'j}·¿"!½R¿Ièu°ýnîÏçáIꀠ 6á™LÆiº£¼ZnKúíqGÞ~#$ëÜæéÛSª<—ux±Ü‚jV7¯­ì®Vyë‰ s˜AO%§À¤~\æ'ÎqKi÷”_Ýí+é´hÌÀdØ÷3JNcD01`åþˈg¶oOãçÉ' bw‡Z‡ ª?v/”ä7ð}Ü#w<ÆÍM±íÍ¥"×ækUðÃԞʼìà,7ƒ|P >ð”`C~L¿FJq)&µ]béÛênÕß]›ÓçÃÔüÖµçª8;ûæâ.ˆ§Ë²ý^°Åª< TßßûbÄ &𢖂A–ýü<×$·Yo9%žÿ±NÑÙ"}€7¥wö‘QŒ9X÷Qy#‘3ª ½ÂKŠäéùôc¼„JèèëbûÄE³U‘'_²¬¸¡U°L/ ª2CIT< ýžØ¥ÎâÄMVC"86óå.%ê 2ÕQ‚°C*Á/§üŒ5^Ð`…*nÿ Ì‘î¥z®Ukë<Ä‚"ýÄ›¨Ê“‹@ˆO¾&ÅÑÖÇþkg"£È˜A‚Sq˜°yð›B;ù©¿™ç€üÞ*ø¹]úr¯måìÜE‘ë!M"£³Æ9_qŒƒ…ÓzZNüÒ³ ½7t¦fr¾ ¶]õ?H=w€«Üÿ“¥I-Ó7qÌ1رÂ模‹ì‰r-rO:l‰Ø6ØŒUú>qjzP‘Ýšk¿Áâ§GóxÏ¡-¡sŠ53}ÀrùEhl«ªƒã÷세˜«u-¿R6·”œÛ§wï HPœ7˜Ðª*ðu®“_fžÈ¡Ñð*÷Èl|õB{!ùQ ê+ç•®b¤#hÞTi^/‚‡m¶T&VÙxt]`Ð:2¨0¹£Y¥í¤ô#.gòèšWלa‡D!9’ÕqJn<±e… þqZ*¶Æƒkd²8Š W¬ÝÖÒ\Ü–¤…k¤‘Y9þΦ)pÿXË:=”\·íNPJ{åé”b÷ª[OÑté#Dz-R¹»©rF†û~ðì6œ XGMöÇvãöÆþ/–hÁ Þ4~•.Þ#¡X3û£ ÇôŠË¦ cËà™—„kï&>M.ب¬ªÙ r#öÇÅXY-ô’’"áp#v‘uÝ¥›-©/þ+J¬&Xüߨk&¾D¶GФÀáí—=[ñ_?L3u?h˜¼ƒ‰›(/b“ÌIà!Ÿ8‹Ü{ØOÇx“IF¦ú†96zÇè¿r{“uÜf_Ë\ØhÌôÓ¥ÑÊ‚~áš’¿C†Ls0ïŠrH£NW©J˜Ý‚ÍÆÈžUÊ2ŠH¡@à& w籃“èÒâú#MEz£I6û°éÄ>:aùÀPy®ë“ª-^›ÌåHiN.¦ÍCTÈí¡îø#a¾Ô bÛ|iÓ`À5v ¹hð…h^6Á÷Œ½$ \®kF»HóLjæÒ>Ã04éÅ–]‰scˆ»ñçšq_¢äY(?p@b©ô ké>È&õµ mxC³XÆ/+="†´c:S.veß«\&–þ«¦œÿ–}MZ¦E‹„5¸LhmsàÈ›\\¿c¿+ÆG[ ÓbË^>žÖƒ O‰#çb6U0‰[˜'Ÿ-ÍÅsâ… Æ)sAê¬O„¥šØ¦4¯úz°*}Þ¾™¬%äxùÙN.& e"‘IÊ뙸7]·žÃE‹uî£~oâžg'PÅ=ˆÕ¬€Ðì— xqÉÂö3 ”²8NÂUw#0¼ž{{š<6Ð>íëi§8©äš‹]‹|}¯œÅÃÍü%Bƒ({'Wxîýà>­¥ÔÎZ¨óOîÉqÖ@ï"J6l›±e¥ä7|É5aH8x‚gãMYÒ#/èð |Îé1 ~|va0ÓIíÝùCNF‰ñÛÉS<[o8ñzÀ“JÀoìØ7‘8ë™Y»Üú¿Iž~‹Jvú1 ãÌ/„h–§eHÝ&iZQ¥Õ;£¨¦$°r8…¶Þ9M~"¸ ¯.—¼™'´ Á©"ó¾ÁAâ×cûU’î©@Ån³Zø\0†„.xy©hÄFF{ÆìmÀíÕ¡š¹¨ˆœ­B“Ÿ×­j¼âº R©"r®Í (ô~“¡Öõø)ü˜ªp­¤jóô­;}Íê C‚ªµ%MO—€iNUàš®&|Sá#` >m?`®á‘ ž\ìžÎ9‚3#€KVýµi>|«dM‹ŽÝ…êïPQ}Z†ˆ¨Y†Í¬&{3Í2ÑV¸ÇLyí®]ÁD« F}]+Q‘‚,ÿÜ$Œ¤Š÷MX+RAå+A]Uö#±ñ|vÒÅ«}’#-AÃC åÙÇ1ÖÍÎV ÏW&ªGÔÅ1 ™oíx¯ä _€ªeîøîkt”´¤õãíjµ÷¼‹Âø2Ÿ9ᣠ;ÆZ†Ö¿Hšeù\ o¶!ì¹4ø¼ÓüT`ŸUÇdZæÓ"\s?[ç‹ãŽÆ`SÞž_þº¹ººyw¾H„”ú~)bŠœÐ%Elir‡KÉŠ¼µ ?-ë  ”:wâÊ©”š†vñk %²Î ½IÅs.¤¡”Aöø æÛ¨r8Ì}Í×_<®Qº“;Ý¡ÊÖ`¨QFõ'âT ä \ÅrsD¯ äZT:±Gæz‹&w~ò•+»C)gûµoëC_H†«èrj‰¤ÅDè½jeh!ö. U¦—‚*„NÅ•jÙd‰cc¢6ÉJ’¿ˆB\Àå;‰/ *Y¤Ÿ%Ún±Ëõ¢®dw»cwÕ=‰Ê9Àf—øØ<M\-߶ÞÚ 5B¿HtÇÔîÿ˜%ËÃÁîI >0E%4|7b×êVU<3ØÉCì2›4a ¤7ß© Bv.þ¢¨$v²ºîàE›èò€¢Õ ú#r ¹M|¯ûÂÉe™¿îOîâ¢D‡Oa+x3BÅÛz‡öøks;»‹ÑQwçVjíÜRׯÇ'2ÀÜ|ûá©S ’} „-Ÿf¡Wâú»1žÔðEЃzu#D3ã èÃ/©jsçë^ÐÚÐ,û›òÅ.åìi¡5Í .qÄ°¢s ÌE ¾4Ï2üÉ èbì"¨³» #‡n¯á#üyaçýSµÕ×<ø— ?ãl§žÿ9Õ²O endstream endobj 259 0 obj << /Type /FontDescriptor /FontName /QKESDY+CMR10 /Flags 4 /FontBBox [-251 -250 1009 969] /Ascent 694 /CapHeight 683 /Descent -194 /ItalicAngle 0 /StemV 69 /XHeight 431 /CharSet (/A/B/C/D/E/F/G/H/I/J/K/L/M/N/O/P/Q/R/S/T/U/V/W/X/Y/a/acute/at/b/c/cedilla/colon/comma/d/e/eight/emdash/exclam/f/ff/ffi/fi/five/fl/four/g/h/hyphen/i/j/k/l/m/n/nine/o/one/p/parenleft/parenright/period/plus/q/question/quotedblleft/quotedblright/quoteright/r/s/semicolon/seven/six/slash/t/three/two/u/v/w/x/y/z/zero) /FontFile 258 0 R >> endobj 260 0 obj << /Length1 1138 /Length2 4987 /Length3 0 /Length 5700 /Filter /FlateDecode >> stream xÚ­Se\”{·•’”PA„ƒ>t3ô*ÒÝ‚„Ä8 0Ä CIK—4ÒH‡ Ý!H#ÒHH7 ÈϹïñ¼ç~½¿ùò¬½ÖÞ{ý÷ÞÃʨ¥Ë+m|S@"м|€¬ºŽ€ ÀÇOÂÊ*‹‚AÐp$B‚†Iâ‴³ ȈJ‰Ið‹°²HwÜÊ pÈrþi{ … uÚf­…غH(†vç¤íì_N€Ì †rYð‘p(x³‚#H@¿ )#,‘ø¯°…³Ã(Ê k àÀšä°-;wÀfIÒ@b{Á°Nþ?Lý»¸‚³ÄþWù_Cú?4Änçþ¿¤½ƒ3†Ô‘0âßÒ§°¿¼©Ã,àÎöÿf•Ñ;8Taeøÿ Áàn0 -8j XBìœ`Æa‹›ÀÎíO •§úúŠÜíóON G Ÿ¸;ü]õ—øO,ðc§ƒ‚»Æü|üüX!ö÷Ÿ/“õ’G@‘pö DD q'Á^‰as`nXà >M°3ñ,‘(’_ë Ù_¡?X)þFâHóo$& €ôÿFØ]‚ ¿‘zþaó #aa,BÚÛÿV `_‚ý E„%Üö›bý(€à¿¡?BüÎÆAÀÿÈÆ1ù»=Ö ò¿hAäð›Æ¾Ê{“H‹(°íQÿ€ØöN¿ûaI'ìn~ÓØ èß4¶9ÚûÇó°vÑ®È$`;ÿ†‚X?/~ûÁNò õ—üÿ^•Œ Ò̓WHàÄvÀ"ü^ÿ¥ƒ:£P0úÏ?,ö4ÿƒ-áØC†ÁÜ`P’é $T2ÀæumP‘·|Îp1ŽŒU]´FUÛh ©ÿT Ž]~¿ª#×B¥ÁùÛ”[äkk÷]/èš=µöü£“Æ®¹˜¯¥¼h 78LQw_u`ÂøoQ4ÕŽo‹àhŽ,|,Š7ÌíJßïÞÊÒâ{òpŽñZ»±Ku{j€(Ø@!ÅN/8°’MˆQ‡2ɱ(D8xÞ•2>~ÈßÛ&˜¨ž{öÙì|ó<‡èMÜÏgÇ#iÒÆEMŸÆ'­'ìí¬!áJÜÂ÷#r^¥64^œ—¦¤†…jÙ¢“cÓâ ¢òõ̱ãýKtžÕéÞ|/çÆ?¾Qsä«\+Hwš»«aØdÏ4¥bøxõç5Û~8o§…j<×sÞ|¶åОTÖt"¶?‘œ³l:M¬ ^L”ð2ƒME%)ßD2ÏáÇTºÎ'< §J{—–LÖ¹¤5xÁc¹»U=@ÌUL±ô\1KÈhTp¦Hk/¡@LMè µ™Cgê‚€šÉw¶Y—z¯[‰Gáù•{6¨s^{^%C>')-Oy ¼¼›gÏl,õ‚&ËÀA«£‡^CV¯ |¨7Q þ”xøÄ C‘•AèfvmŸ6à~xúîé8&µ¡kÈtÇ$éiC¢WjâàÓø„Æè¼ÉÒé1mãW CЛùÙÉÍE%wØ­z‹œóNDpÔ%ánö|ÅÝw!]ÞC{ªŽ+·I„æD¬ Õú˜ Bqé(%è„´.ó·1ÑRV#·È<U¢uƒi!k¦pÁÆàÑ Írœ¸ÐSuê$âΤ{/øwâù*©Êo¼?iºt¥ Ôn6•»É’Û7½ø!Ù¤÷‚ëͽ·›áñò›…–¯p OvFÝø%…ÈÝDÚŠ¸ßhR[NÑÜ+Lû¬>› Cz惧œ˜ž^°=.-ÍÒÿ>ÅW ¡ð^VaûømZÞp¼ãb+Uë~µP“ZÛe„!òÈ wÞU¡+RdèQÿ$Ø.>Û<®tÔ¢Ì(ùý92çTºlŽƒþ£jR3ÉÜUÓ…‹q¦¢m¼„ŸÈ…í«nw·[‘m‡á­ÔìÌå”á<•³óµ®’ÿ¼Áüì¾…Ä„…_ÿQŽHïXw «ÁÖ¹¨{óxÕªÕ÷iµ­¯ø?JáD¯[-9¯™¤‹ iÓª,8:Bßã Öª$]Í9·ªÌêÇËot¬WßRfº” ÄŒ4œÆ<Ôµo6ÍÞsdáKd§} õµx®ÒŒÊqÌA¿ íÈp—œ=ù:“pÙ?æ¤_åPþ>΋RjÊ«kÝNü~vÇÎFPºaBk_—X‡¥³>³ßPÒccJˆŠŸ5[ųL<øº@³üeImê$‘XÓ)J®Ð¸Ä*¥ñ%åî`÷-ÖŠ’øá,ü¯Ä3bUGyBÝÓ<Í6ºïf¥†gF‚ ç^6zàõ­LäÓ;<ßPÈRØnݵmq©{8àçÉ%¹¦•ËÓÏ1áxÛ?88pGaL–|x`Ë ã‰ÖÇ¥¸T%ÖÌî‘Ê/gÉyi–6XÌ¿ã4-JòÇÖ`þˆ<«ƒ[ý2õ¥ÛæG“òõ ?%€cÁÀ;*rœWY<Ê߸¾çˆEÊf¼Äö¾´(qÚÅÓÉãYq/C$x÷kL%Á ›Ö/X·}&C¬÷í=K‰f gRn¤egˆòFÈGÞ¾r-ì`¿Û><-íf”æÐßôÅ©Hë¤Qgí„*óÉ—‚Í_ú$è±O½Þ “Þ™¨LʜƉÙ'mR-z'QnÁóû«q¢tízʃÁu­b`O½€‚öªc5:Ú¶J†’ü”dgƒKZ©uÝñlŸs‰áO ža¢èÊ€% ½KžbNŒ¾{¾ÌÍ ¥¶= ‘éJc”_~çV«œÖüYm!D5éRDÐg¨ÿ”ѦܵºÛÑÊãSš2üVj8£YWk»ZÌ´ñ(÷Œ WS;—)1ÜΰŠ*˜XƬ°»VÔ´,¬üx±ò6¡ŒZËÎÏ,Ú¸‹Ä~› }B.É1D?ÛòEE 5¯£N"ÙS2.‡/ž6û@SêI?½K|è'´%º®B0Ÿ.°âÅ»™²+ÍiæëÓÞÁ©¨ˆ!‘øÛ„"éÆW¢J:ÐG-û}§T‚4d‚czsOÖFá¯åäFŒf,T™j<ÓB·$Øž%ñG:QºH¦K$û=®Z)£¶5öq=b6ÿÓÎ}3FÖ7v RŸK¹oÇÄ–BN`Ç Ç8%“gµŸ(ËW±G›¥"æ8lðàÃWn~?·Á·4{…­ÀHÙ¥œ˜wÁI®m=NË;ì<‰jÀön$¬:‡IwaÐмþ Ðߊ×Þ´ME¬rËßó‚TÑØ£Í8r¬.sÈ3$¡I fô–¾@”·0†›p–ëÕ >U—Õ±@ m_®Æ°u{Õµq „œçJŠ'E;†‚ÑZ½öò^ÃõüWŠZψ蕓ù¯ûÓ«Ê_·†¾ôð9”2’\—z‰Q¼¯ô…€ø†kÆð••JšSE5¤È¢ÉlÃ:C“ólY[/^ç˜y–¯_¾™¯ Ü‘§/N¼uª²´ÕMWjòª;.xJ`uÑVx¾VòRïêq0ª-vs÷ø:¡G˜Œ[=Pa½f9ÕwÆK»°—F”š5<=_PA0±ä×'¯^0`€° µHf|LöMü–ÔØc¹{ù!ˆ"=.`é0…›€¹æŸ”=)—4ÙÂëuìEs *¿´¢ë3tÔoà)kd¼‡o>-këú~/ä‚KߣË_FG3~ÑpC[e¬óZ×ôÇòD~%ÙÝ„ôGÀºGኙ¾iÖ.S]_þ¤ó¨·•”…¾Þ’–—Uºh3¢æ&ÿ¹®‚óÙͲ[²d9_<‘Þ9 A.øŽÁ›œè„Ú‰¾»@ÇFŸ¤wÖha#&`àK„ù h(®cÔ}eþ"õÑn§2Ñ\þ¥"¨ËfJA R°Ž³A퉳s…¿÷«ûYfÝZŠ¹¨ýóÅûíW<ÄÍ•ôíè›/ã?á Mm\ w\'ÎÚ»‰£^šûÀä²7 m³íöÃÖ¢?{n}|28¼1àBcŠ~c—!!0Œ÷^>qWϼ¸¦ß±TÝW,(Úù>\­ÊÓýŽS'ð[±Óùvsÿ|VùTT›Eio—‘cóPvÏîÊwy³¿éM¦?/éBÆíà΄ðÓMâg•v7[5ÒvBuI¾‘* A1ß‹l¸>SÖ°$Ú3™uÆ;6Æ'w(Ú¹'Ÿ.’VÏÿ$ÁOpš„Ox{=ì[•I­$‚wecxúfõÜ}³M—+‚7‘J¥ ‡N— >jÕ¥¼º†²p½ÓûÕÓÛ EH[þ û ?ôLúì†s¤¸kõü^ñnÄÙM®…ú»ý*O^Çp|r÷]pÔŠ¥ KÖ6%½Âä1‹X.A`©qµurêãæPoD•ÞÞµ¦÷©ÙRq×oWä‰Ê³Ö°È{@yë³äåÕȲ²¶Y“·ç$”Fí­ƒÀ)ð <ê/w£Çi —ã·§T+ÎÖÀìéM?äûѾ‰¹²Ù$ÑׂKů« Ä!ÅmhW]/¢W‹Ñ‹9Wˆ“Ξm#xæ!zÔX©)º E=‡Ý#Úoç—@[Fõ¡`.\r¢±ºjêöÁ’ÊUü.sÁÓ×^Ï2ØÕ¾l˸—§óƒàQÇz·¨}Ã[õ2Ïjæ8}Cr9º ☠·ðxh÷©á3¼T$¶zgD#"U“´×궊!¡q’vWNG^(¼]=ËÏe$Ž?_¾ÆBB¦jÏnȳ\H´>!{ÿt`gîûš¦í` 8}{q0Ø>ôÄñ“cçõW4N„å_~Xð‡HudÎØyºú6 kpÞ,Ú¬Ëßà¤\u…þ!s;ASÜ YVô(p%•^Ϙõò?rÍl1r÷po‹Ý  ‘º~ÁÙ³LÜUo<˜Ìù¨²HQ­§@•ä9À~%-X¨TíÌS›nàÊñj?úHCð'8W-k?ÊÄ8aš©gÒWi£÷˜u«@àÁèy¿ußím¨Ýn‘ó÷Õ‹ Žô5óv{H§OdÐû±Ë†ç^±LU©ŠÎ÷¶kY¦„½C¦£xêC½%Ë €ºåb}Qw½MêÈBFCåžx&¥™ŽÅa_4·Õ$3"[Ù×óžØƒrY©E(c‹ÖÆÝEø~$ñøÖÒëU¸bãPZ—¸é«jví轕i¤ò^Ía*ç‚Ýu¹mïgVL” 3Ë ÷® @¼Æbƒ)­ãɇ“Ï$KÝ7¼—&Q—Þ÷»ç·Jqg™e¿ÜYËÄXBü(“ßê´|ËÆ‘DAAÛ£mÔ7Ì“ÑZJú#öù]žZ5<‘IÒtŠ*|ÜÝnáîƒ[ Öþ7š»ÝÝñR>#øV‡ú§yÞùGp;ñ4FÀ ¥Î*KÃý\׌e$Ähu Ñ}ßí¿âÛ£™~êÅngÎhª¼~”ƒ¹À¬wÑå5°n> ›àº¡³-2T‡™¹ÃΟ3ž?ß]ó±”<ºâÑva\Oî’à[t’˜h[Zæ“—¶—3¹Ø›6ïþ@Äi{Å30v#Ó‘æm‡ð ô²Cƒzyjr ³6ŠëX(˜=×ÒÓ¦«†‚Ö[ ³jÇXÀ%¾&Šš¤É\¶ô⎮uñÉOÅÀ˜©!〕„~õ_™k2OW©za¹6Ôá°w¬§NÓïÍ1§kõß ŸÜ\Ûö>"öz¡«ÒÖ¼à¾^‡~¥™ª\!c«™ü+­¯¨³é{;|Êîd¯ž=» ªyýCs¶ß‡Ã.ø3·P–¼äfR_=»*7¯5ùi 0~‡†—Œ~õÓ;'tòb™DÒ—.q¦õ0"À>¸µ¬ä^ÐVÞf‰”3«V û’ñî“맷´Š¡Ù’IáŒï!õˆo,…L^í}8óå$Z²úï„¡ë‡*#òð?*Q.“Iw㆜.;û‰èÓhð—$µÓ\»ÖÜ·Æj>Û3è!"1sK&F¬ÅüG+cCÅ‹õ(qM™{¬/&¯Ï•è¯n †}m\ûã…o9Éì@ÚÅ2õ³•t‹ÖYËdv„·e³ñÃÐ\ èümí0@â6i²æÙjwrDW¹{•î{å„—4Ñð6//QfuõgÙ±G²/8:ÏŒ}üäÊÒS“.Ícº7ežgÝÍ *s½.¥wëŒòß?ã:œ›ÛRùÞÆâ #Œ–zþçCî 3?Û¢›j˜õ¡Ì›ÄEª Uœ?z”½úüóe¼ÍƧ÷ùTŒ7»(õ§Lõ‚Ù$¤`ô¸''èÔÎöv.É.iªñ`×¾ÃWõ*“gd#i¶0ÊE"2‰]ÝdÍ×{1]$Þ™D߈͖P-îýÜ÷2®"dOpÄ#"½=•)Äe„v&+ç4m(<û×4;ÖKŠ,Ƽ’…g1è®/>ì&ºâL¡™«D$SäFï+h>5ySã |ÅNNŒÜ©Ó†¯g7òñ€#Ižó1쑆Š_=xEDU'Wd¯©ý¨,¾·òÈçdÙԬðBôµ—ÍéY$^°¬u“ÚÛ|:y·gacâ¹Fâú¸h"ã!cÚA¾çÞâ÷§hÏ£¯§;Céµ+ž©…Ö/µvnÿœ³»¯qéy’ÇFè÷lbîÄDÙ¥ýhTâ”8õ®~ÜS]ݲûºŠÛ=(–¶e}}¥äª{‰|žÇÔ ’³p~ƒKeßp.]ÙÙí°j€—–aÿMÝ™2…uÖb{zf×ÈR}—NÝÂ3Š0çS^Ôî©.¹Zù?ÊU* endstream endobj 261 0 obj << /Type /FontDescriptor /FontName /JWVXVG+CMR12 /Flags 4 /FontBBox [-34 -251 988 750] /Ascent 694 /CapHeight 683 /Descent -194 /ItalicAngle 0 /StemV 65 /XHeight 431 /CharSet (/C/G/O/V/a/b/c/comma/e/five/h/i/n/nine/o/one/p/period/r/s/six/t/three/two/u/z/zero) /FontFile 260 0 R >> endobj 262 0 obj << /Length1 1032 /Length2 4132 /Length3 0 /Length 4794 /Filter /FlateDecode >> stream xÚ­—i<”íÛÇeO!”½\–±ÆØ=c'K–’-cf03Œ‘]Ö„l²&!ûš%5–PֈȖ}_²$Ê3Ý÷sÿë¹ÿoŸÏõæúÇqþÎßyœÇõâñšš‹k °ŽH,/.%!¥h™I)R’t & ã°-©H)*Jg@Z’W’(IËÒM¬»åì‚„5E~)nH ÃF0¼ Ò¤‡¡s,…ÄûHh4`ök…'`†ôDâ¼ :))‚ãG¤3 CþeHã„þ#îÿ¤¼8O’)@˜dR YD`1ht¢cI{!INþ?Lý[\‡€FÃÜ~ÉÿjÒ¥an(´Ïÿ`ÝÜ x$0Â"8Ì¿Ko ÿöf„D nÿÎêãah\ãŒF’‡Pž:(o$Â…‡»N0´'ò¯8ƒø· Rßþ²6êßÔûû>ÿÊ™ÂP¼…ûTÿÅR¿™ÔÊ°‘”””"’žÞìþµ—6ŽE 0¤“`8̇Ž4$’|¥ôÞ$Ã` OZzâ8aqt¿®SA ëþ ýMòøêoR$à?‘À¦¿I›ÿ‡H7 †ý&vüM$øHŽ”ƒcѤÉù'"E:ù’”ÿ@9ŒúIëÑ¿QŠdê)Òü‚± 4vÿe0î$){þ¤³ãû$ ãïü¡%M’öù ÿû®¡P¬·¯¸Œ .MZ§(+(È*úÿŸ:8‡Cbð}F¤ù‡P¤ñB"½‘pºO±påP×”ÚðÂí¼þ"*ÑSP纇ÆU¯?4Ÿ¹7 ý¬ÛÐCt²Òê{q ÃÕÏc.ÏûM~×zt6ƒ=¦ÿ\ðrXH»û’Ëj'ÍÈgÞïàÞ*ccíÐîšÜ)“ÁÉw…I7Ÿ¶?ÙêXÍ1Ö²X¤ùÌKöÆÆ«úMz¨¼‚•NÚ2"¬RP†×ì\ªGa¤lÄÄsI ”}÷\#hëÅÆ·±Mæïy´Ù‰?oÑØgçÐ](_§¦xò”Kº“œ×›z*ReSâƒb>–ŽU>Ävù©_t ößN5—3¤§ÓÞ_Xï åT+ëØ6YW_ k0ž>v%Çìÿ:D è¸t-ìxQ³Éì{=¸»›u¥“ög|hö ZcEùç«B6n1kµꆔêïâE¡œçŽÅ© ØõJšçî}™#†Ú»½GúžÎXqKpìÏ[î|Åý®¶j¾r¶£í>c¶Gº>硃QYÞœW*þûw9ŠÉç¬oQó-ˆ\ýÑ»œ_¯¿×øà›®^úñà~NÖ"•5#bãúvÿÍÒŽÕ¥TH—Ëí·ß&¯Í¬[N´ Ci.éj¥–mƒˆý=‘Ë•4lT*µ§i¾ŸÉì]IÀ°@§:,Vý³2J…yT¡í¢=ªôÜš¬De…'š!zzµ cZ‚NdÕ &̪ô±?a¶ uXφfhå²R%mM.ÿVÊï›·…È3É;(2ž0pºí°ºiH¹arºÏnC¿ó2«/¶­U¹3ÍÜùb>IjjëkiÑ¡ü+*RŽá/o24Kög•œ h³²`pkLSý¸Lß;>ø„B¶^ïc5EýÏÕúªUþ€‘ötÅ…:½½>ùÒ/ªž»”{‰tLÜà2OSE‹UÏVB¿{ïpe' ¥|˜¥óÝzúa¹òmßPoOgùs'ÕX72&?ÛXç.Aªt=Dw~Ïábò,Ws¼~Ђު=;ÿÙ5õ™Sýí|"K1gkK; ˜ƒzPôŽ×võ-]'BŒUÓÉØÖsÄ¥’ôO± 5íq¨w^yPx˜ÕÆ·xÚkÙñq»db¯@ªRß0†^Â.&VÉÙiQçøŒA«cD ý|QÉý˜T¾åNÿiqãn³¾îÝw±çÕP ÁI²ŒZjÐþN«Ï›Â+‹(¦©kLb.rb®®"5Ú¸ˆ·Ä8°êOQB~hÓ •×a±5ÁÅ‹…Ì]fùqþC@Ý·Ñ[ÐMÃ75'¬ü^ÛÎË(¯!#y…±dƒOþ϶AA+ZÅß”tjÈß)}ø-'…Éòúæ§ð~ª¾TˆôҨp¿kw•ç½Énë©ÖRRDBZ :²(=BîZTĸRßøôfêÆ£Jäµy¼"Y-iÖØÙ—òù“õ\ ,’ü"¬ýþÌLþÒ¬æÎé‹×zõ¤ŠWÍË}.¼I¾÷Π»4–ês³ ~ʼn2üÍæ›g×$å.™W•pë ràw\F12T]ü¼‰&£/†WY¾˜(€,m©SÅžðK¡÷v~6m°0¥*Þâ`=øÊ$1ÚÛSa-™2¥QoòÊ U6·ä:\Ÿ(îéžèÏiÝc*yÝ–› ¹ÏljÇš¨‘mq†=Èõ†jÕ®)J6 ¹Äìž)+T“e\¥aa4ï–c¯¥”¦ž[ÖÑ î­ç›Á*ë’›Tô>»LkÏæÜÄl¤ÍŽ¼kÚ´Ù|$ÏûpÏ\¥ÉLò«s'œ€{¯÷æEe¸ÍŽÿ‘Š¸÷ÁäþÇ­Öt¸ÿc!վ΅Ø5*»¬,X¤xî°Ö™áÌ6¢¬³8¿[ižÿ­‘\b‘ªùíÁäüжs‹Ù·æ$ ˜ž1äqiC¢¶¬f}2ð•ÂÛ‚ŽˆøÞ茜] —˜ž¸Ü•ÞëÍ&QÁTöZ<s@ò¢JÙù,«_:³mæŽé©ë@”kòÜAÛB]%gg,i,= ãÊtqW–¶÷Åk/ŸY^ºÔ7õ:þ K_%ȦPÀ_tˆé´wu»ú4!Æ+Ÿ:­74O(ÿ©¯»3tG„¼kP…Û.F‰[¶=’=6†¿eß2ȯG>ÍOõ³TaÄðýK…úÝUž°ÓO÷Ïž¨e¡8TüNvÓº?Õ‹äéħ¼”üFíhV{ò4#Ì“%?¿`:™¹Éy±ŠÙB†‡j^Òl²ù6À@{ý‘¥狀Q_Üú!ãì½\ú4p%<•âöÉ:‡Ôb8¶=¥Ÿ?¼ijVÑž[ûlblákBj®ßS¨¬Û©áÈv%·9•¼†4aDœM¸Â9õ+>>e´#õiZ-í^¯¥'àФn²®/¶_l¢å  ~ÚpÃœ‹y³í®Cëó;³ªG½ëÖTÔÈC{ÜÛîZ˜´ø. ŒÇ1YàíôlËvÆ)ýÈH\Ûç¨!ÒÝ´¯ÂeÅå2OªÝ#i_]óÓ•f¤¼,/åZtqˆéõ·–ëëb[š‰³‰Õk"B\þ^ØþúÌÖeˆr,Ú×õ)¬Þy®–Þ|9©äûál­ÐY&:hRñZЀµFvEÄO7Ô…ƒJïXiË空¼qTTœ=;̘c‹ŸÈæûºA#D"tö“ÛcÿÎËjÛ§õìÎÜÚ¬Òé/ÁÖž±Ôq@š•…¼ ¹…ÇçïL‹FUž.P·ÌݲÚßì’7'P³­M.(vñ0½ëlcq©Ì¸_†f¬ß@Eå«…Tƒ¶>O)ÓÈ dLgnÇ´Ëæ &­h-œS)Áó­=ÂÝɶÒ£âþQ¼vLжÊìã{çrjX×DH_ÒRJbMAIÎdtV,%TH…Ý/* °‹©éP×l+/¥3ÏÚɉXK4Ëô‰®…=e8x®5óä•]c«uWuMÛúëCÌç£â4U³É¹+ú>ÓOgôÃÎ$œs5Q—Ø]4î–My5…«¸k;k-:´\ÞsòªêÕø(Ì•· E¼1·è´ƒ‹jó€æ…òDîu¸Œ]ƒ#°ðj†kÓí½pCßç~÷¿ö„P1c$BlÊz6Òµx}1¢¯a¥á–¦—v§­VK\Z¶·*檋¥+aœ:dy/ß÷ñfßþ>ˆÈfN‚±? ™¿.j}o09§úFîÁûNð˜9šÀ’õ¡÷×h9l tÓEy4ä|þè «ˆµõ,›v°ò–'\#M.F¯E°¢œ?±n‰'ð°¾Ù–Ž¿ì!"hZx·%‘ï”R=^þMÂvýx…KhPPfX®ù«n2¥°$W¯*Lf­:õ.ìdv¼W-•‚R_ã­»×M·´’ÀÎ9ù¼ÊöBèæR°Sdu—¦Ô=4ù"ª(ŽQ–øy7k—{¤&+UèeL!E‘IÍä9ã—GF>}öí³ySßÉ á÷X­5Ýk¹óˆ°DùB~£hì­ayüj õÜΈnoB¸f5ÕÚÚvcÈ-ÌïÉÙt}þ<-±z«½Áã1øÕ¥RÙkŽÍù*QÑù$±ï_ׂkû9.z·½HfîïÓfÚWR>®]Д¢áàX[(õ.9›äí ¨î¡Ê‹ñ˽V›5á°ÙØgÜQ…ìæÖ7 Æ&Þê‹l!j÷/\Ty“máÞº¨xlKè—Ý\ãœ(èAÅï^9Î]pψ‡X€÷£yåaLYÍÝìì^±@°i'Ý®cF?³7­®Y?§­‡ûyÐÆ›ç0¹[/Àrvìäç>Ág¥lnª×7"¥›CÜ‚¯$5u—ñʨ† ¼ŽÌ4ÍqVö,…ç•8Cz×3÷.¼O!kƒË™h¾ôÒÎYŸÓRLŒV/ôð? \r±õ÷k4{Nð¤iÔ²‰ÉP¶c)K|H¹Ã‰WívDY4î/PsªOÑÁxö×p~ljYc$è)3¸rloxÍ©:QεÚÉɤ>Qbhïõ)d;·©+éGËw`"ÛA$‰;ºOý®¨÷CÊVß+OâíõÏÒ³j-ë×±[ŸæŠd¯Äsá˜å‘”ü3¨­››Y&)è®=GÏ^gLX±¿"—sŽ©+üëÒ˜[Õ³û™šy¦!¾‚xYÔ@ö̬ƒ/Ûà~L„íQÀÚÙKg¼ËzÔ’{±å E›0SŒræR<Ž5óGy~|tÇ…&sù5f´:šÝvíˆN~D?Z¿|\¦ åÏ&¿õ•¥(’òhÜœ–ƒ'‰,8³Œ»{Œa;t¥½O…¬"/ϘS\m,—°úž·©E±±ó1ïp&Š‰›°&ýø/-ŽÈœÝäq¯Ôiùkiw}ÒVêåÓ.Çz]¨›ƒ–|r9eÊRZ«x¥îšò ­6Çw[ýä¢õ]ÿ—¥S endstream endobj 263 0 obj << /Type /FontDescriptor /FontName /OBFNYA+CMR17 /Flags 4 /FontBBox [-33 -250 945 749] /Ascent 694 /CapHeight 683 /Descent -195 /ItalicAngle 0 /StemV 53 /XHeight 430 /CharSet (/G/L/O/P/S/a/b/c/colon/e/g/i/l/n/o/p/r/s/t/two/y) /FontFile 262 0 R >> endobj 264 0 obj << /Length1 800 /Length2 1704 /Length3 0 /Length 2260 /Filter /FlateDecode >> stream xÚ­Ry ëKcÑÿ"PX@—C@@—I¢CÿÅ艘Ú2þg ´Ð0mѦjë‹Œ ˆ5 Ñzáÿc$°ètf.ï—¨ÊØ—,*‚B!òY`|ÒŸ[yº(Â:¯£±SÌÂïf’ãŸw»ïHŸxš,F¹Ül´óE¹§ðJ†ü¯¯¯6‡Ì«0ÎÔwn³D%¥÷.¼ >ú*ãX•ŠçÇ öX Úì‰I™Û•=ÓoÑbN]/ZŠRä7d½oœÌÅiZ¹½^õ|ËŠ{‡‚+îežÄzÚdPöÇž*ßf°ÅE6=¨(Ë‘M=¿’ÿøD„¬ä-­´ÖZaždNÊ‚×ôx×o‡y½o¸½÷ ©J!á8¶Z¨Íœ¼³™UÕóžÊmIép)/±¾¥~¾·yXùxEV„NÌóžS-¹áÊ‹sG,¶>Žhõª»Ùôð¸ZŽ* Ú•hÖòeeÛýœ†p ¢µAp·þKDË”<ðjtåtP#_ÇÒ`#ãMfMÐ뺸lŸöÁÁG|ÃóïõGŽaì“m-g‹A+ùµkúF i dDÖêÏ/p Îsmo‡‘³ÃN¼œÖ~šÏÖfrl"q³X¸º¼ªÔ”¬=ps'å MFÕ”ö¦#Õ'Ð;à‘§}û|B†7. ^ 6>0Ï.`î5%¨íš·\;Ê3å¤ V¬Êx~Üñ=CbÎH’_4ã<£Ò:›¶‘aÕRz²@Žš.i"ðT_ãVbKaÖ_ô˜Üý89F©ã÷ÒLTå/£‚Ô’/uÉ—¤ü£¨•Ž|1E'¸];™):7Qþ<»Ãã®-&QÅ»yÍâN ]b}'Ú¹uAkûÉÚ„ÏÖâ“E¥=™lõ0ž;ˆÀÕèË&”ÁWYÞþù¯â/sŠ¯G +Ú¤Ux•wr„»wäÉ1â*I¾¹¸vâ–oÞ2N‘7Êús«•úŒü`Þ‡W‚õU³Ž’ZÖ0|(¦*#¼p“Ûî–ée­žØ!ä\è2¸JÖÔ~ÿlÓÅÎ$vååg¤ÞkÆ:T§µåTî^Zß`É¢žñŒ3^•+C·y­ÝPþ„¼11"kòeˆ«Jï9ÐìÎöcAVîaŒrBqö`|VD±tê>cnéDƒÄäá'W|¾ j…%’%}ijh;ÄØÉGuŸ¨™÷•ÞÅsXI{ô5ìË>¡%x6,7ðˆãŠRÞbd=þ+…)$º"@êó¦#Þo"e»{[KYy(«Sêpu“Dl%òÔh¤+½àËö÷á§Ëím줅“8jî†1â–·›ŠMt±tüq§êƒ§…Ü·ƒmL0Dófî­ì|ýB^ÆÖ{9µúá÷f4c͈ÞNçš¾1K{AENiÕ5hS<ÝÁ)šq[]T%³šÃ¶ ŸXedumf]FIMýõh~×6ìã¦s2û‚ŒÁdí; g‡ÂP@Ç·ƒ3Ñ®Ê{ï†tú¡î/R.ÍS½Óe˜ý×ù¤Èƒ+¥>à¦'Ì$>oµ“’Kþ¬4óªòcmÃt¬j‘c˜g5ðmjˆÇH¤RêŸQ·!…|Rué£ Ûý;))¯“}7·|{wælºb#NÒ¡Ìï`ÕJEµ#öA»¶¢’AÿX!¦ ž¼ÍA×6aõûÔƒkÜ3mÃ$­põ]Á“øï[Mã´¦ÞHÝ1¯Þ$±¶B5ÞËcÖVm­s%»Mcö¶îPE<ºÑ³EáÓÔe÷²f´/…ýÉÇÞ}}±­`ôâu$á*Þÿ –[Ñ^áÂí2Ï|#_‡éÚØ=“¸žÜ 5…笶K¹õ¯5Ý@¶»_ß.÷±sÅÛxžñ·ÁÏp’õØ q¥œ?Â62ÅÓJêóëÓç,w[LÏœl˜"tÄîÙbœ«œßUÂúL‚&y.„ØþzäýGòžƒc‹…©Ÿ¹-pÉD¤ö 0½´°ÊuùÅÍúvÒe¨Ûwd³Ç/{ÌÞK!žªÞ¹8Ï ÅVªé”FÉ ­UŠ‚^\ßhÚ2ŽœÞßÞíSúUQˆ>Úv.® -¶> endobj 266 0 obj << /Length1 800 /Length2 1698 /Length3 0 /Length 2250 /Filter /FlateDecode >> stream xÚ­Ry<”ëO§ìÇ~©/²f™™ÌÈž‘’lÙn˜y1ó2f˜‘¨c¹* -$—0Ù·c)²eß…P"®¥„d¹C·sîíü{?ï?ïwy~Ï÷ó}~²RÖ*ÈÄ@dª \®šYipU·¬¬!ÄQ‰ù Ž jpMM8`@s0ŽÒ:©©…€sˆ7ƒBt÷  †Š»& ÀÀ ¤ñ82`†£z€^¬x °†ðDÊP H$Àj÷„/`ú‚? Ê ‡"ž ¸‚îD2·Ún²h|§ 4ï’Hñe…X!VDD&1èÆ­vbݲ’ü?Bý<C#‘Îã¼vdz:ú‹Šó"’ÿÑ!/o¤f¤¶Úߣ™"ÍëgÕ„Š#ñdwÀ¾SD_ ‘,ˆT¼à†#ù‚{Xëð»'µèDqªð…1„/ù𶽩¸HÕåz{Q°Gä¥+zé–?L㦈!ÝŽO½0-62Øx?íè—réÚ'vƒÚVŸÕù™ioŒ<{áláhõbW&o^¦¶ë¨&ãb>iûŽ­–EîärÒµhÍw—¨œ0 ÇÔ³Á<«æz²¶×aOÖøyÆ™Úø³Už¾LêMT7?#/Ó‡¤ÎŸl±ä‚ê£bœuQô×>¹þÊË_Ç¥•//ßÿØ]‘ 5÷r÷ËÔû ›päi8Ýn…‰o[Ú¥ '[§‘³™”zªÒJÖ\ep¡%fú]Ã'±²þUX%“ÝgDkùå_¢ùBñëÔ‚&­l¿@ã ™[YeÝÎ|'bS¥=/­¹‹ºäâ‡äÐÐKcŠ›­9ÞÓo³6ÚöátOjNiìZK~|ø’ÉøTeÁÙµòQÿ\¿ÒÄFÇœŽ–mh Û7¶S’Žg;yÙö<”~)ðÂèùßÍg2;ŽØ$)6FLÃTJÒZMí8£‰Á!æ‰M‘¿fy@ü÷ÄŽ&ÆØ{Áj<1M[Bt}ðckýÓº’£– Mƒ\¯¹ræÇ_µ‡Ù³¿ lFÄöíÿç¡Ó¾­ÍìiîIÒ1µÉ«‘-7ù<©¿UÃñ2v©40³âÒX,»0VÃÉT¦<ÊÑÂI'kä7—TzÂptø½´íB!.FÑÇ7´ò‚tLJˆ{Å+Ó „ÂJpYÓç2®êY¡MßÞ·½á'Û®¦ß^/w·ù¯?¾fAX+^Va2¥­Ž³ßgS,¸mx£Ì\î•Õd[%›¯XjGrOlÍ%Y¼èÐyb©»êB³ømg¡É½·rW#húžÚ3¡ù úü„swÑ@½3MUlü¤jüë²µŠùä¢é²™ ré)OòŸ–l“wž”Ã$‘EeN©•¡VpÍ[­\Uv]͉ʷüj„×ÅÖuçSfÇ ×èZsÞs6}ïí¯ø/Në¶27D3M [ÏßLªì,¦“ÇÌØâ•®w1‡aòè¼+ ë"*Xî¿Ï^¦¢ßi]äòû!›^©±%¡r•Ã·ì­‡ŸŸ»x|‡¨ëÓÐL÷t²xâºUlÂYÑŽPS_Ý»ØÙ-GB!¦µç*9V'iìuÓûm[}^S4eYêMu(â‹àb°–‹.”,óØJÖ'VS.$(jÞ­ˆuŒ DG=ð’ŽÂSýÑ=¨K–ß2§Å+…ýƒ-ÃiG¢àL‹’¹?Jt‡K±Ó©‘a ¬MÖÄ’¡iŠÚü<7*û °±‡ãŠDÅ|‘eÀ—ª\¼òöòuÜÒ›ˆÙ"ŒNÇ/&ôšuÈQ¥»!¤¿õ±¶‚6Ó}€ëÎt,~®v¬ßW9‹^ËÕ© 7Ïù‘Õ¨Ws —Õ¹*> endobj 268 0 obj << /Length1 1447 /Length2 8009 /Length3 0 /Length 8843 /Filter /FlateDecode >> stream xÚ­”u\Ô[×öAJZd@@¤†¡»»»†î®¡¥»;¤¥KéîR@ºA„wÎ9Ï}ô¹ŸßÏü3ßµÖ¾öµÖÞûGC©¬Æ$b5KB휙@Ì ^€˜‚*7ÄÌ‚AC#æ6q†@íÄMœÁ¼ âb `e€8yÙxxÙáE1¨½‡#ÄÒÊ@'öö¯".€ˆ-ØbfbP0q¶ÛÂ5ÌLljP3ØÙƒ bcPýk…@ìvt›3c€@sˆ™3Àl ±ÃþåGÆÎ àú'lîbÿŸ”+ØÑ n @7ù·hµ³ñ˜ƒ-0€ŠPø^`¸“ÿ¦þ[\ÒÅÆFÑÄö/yøŒþOÖÄbãñ?y¨­½‹3Ø 5;Úýw©øk `sˆ‹ígeœMl f"v–6`Ë?!ˆ“$Äl® q6³X˜Ø8ÿŽƒíÌÿÛ|l[Š«kªÉ‹1ü}š§”M vÎêöÿŠþUû7ƒ~3|6Žw€ 3 ^ÿýçŸÁm%ag5‡ØÁ¯'ÀÄÑÑÄ~/àÄð væ`wØîÈlu†/ÀGâ°€:büu˜œÜp…þ!Pâ_âb%”úMì ìoâå\Sñ7Á5•þ%n¸¦òobÕ~\Sý7q€¿ ®©ý›àš:ÿüVM~¼Òô7Á+Íþ%xÎ j¿µÿ‰°³ÿ±µý½Ä·hþÂûÿ¬ Åoü‹ ¿õÿB¨‹ãåð-ÿ@øvV¿7‡·håao¶û£ƒüpÇ6 ¼Ûß‚[ýc-üñ¡¿ÕáµP»?¬ÿeÖþw¾ÖÞÄlg¶pþýOôŸgûo~Àöð‡ ýc0 x/t ‚wú= øæN`[Èÿž6×ù­Ê·àìý# ?I—?Þ¼ë×tûcôðÕî ܹÇßøߢ¨(ÔÝ‹‰ÀÄ ßÄ¿Ù\,>ÿ«ÐÌÅÞ¶óߟ9ø‹þ[@àï v›a,ÎAÍø‚­SCË|% &ÊQèE-›bë?Mw`-Ä!ÚË9ЭӾ«H'ÀÞFÙ¦p»éÑî­2*yà›:û°íj¼îÙòRû<]ÁcËžê&觭qæòQiêëHY¢Na_ÖiÿAž2¸úê %Âg=ן3‚9¹´%Óm4`!u´l”ª¸©eaì°U7ÜÄxäÕñ _kZ3Ãò´Ýÿ®-7áAÿroJX(s–ÓÀnlvÞjÎÖÆÊ$2Jš"ª &£¥õþ®2(4ÁÖH›j7#™`Â)Ñü:~vxÔûc–/sàÊLÈHžã&U¹cP¥¥XºdRtH^.H‘=æ:7Ž5«5°5_.XæÛ:L2Ù5.kkî 9ÚÇÐÃþÙÅî½ÒÉüd^3Ù“¨‘`§×(¿ÄüL²è²Eº·öãqïSÄfCU7Œûùåˆúl \µWúâ…#rº£Z¤¤Æɘ„›Ê‰†ûÏWÙpöñàåRŠA¬QncV¡)<>dÒ°ÁJ°¶»†¸Å®°u[ !½L³ègÿÍ)í¡™÷”ZîL±¦ ¢ Ì‚4¤ú¾óóUD1>,û´O>VG*ö éºSíJÓË(SÛ‚ UBÆ´ÖdÁ[£ˆIòæšiJŒ›Ý}º Ù"Ž ü€‚Ô‹ããB•dkgî¡cQF[E6WÀ쇆£T¹»JΓ,€s$ʄצˆ¬YŠ Í”ãÝ‚ë6îãN–窶ÚhN}… öwq¯š!(g¼HNWA„°„æ/oßE¯¯Œã+ÿÒÁ~¢ï»Ä‡”ˆÅ•«žÀܧˆÞ|_XáÃœØ~FË›/^ãûi?– Õ%Ç>‡E,xĨDúE©2ÝSlf_Ôƒ¸CDÉ "xgÜ#åmÁÚùÀÒEòÆš…„¶»êÜ姉c€Læã"G)­29ôEPcUáRïU½²=k¹9Fþw±Â½Žq‘LäJî°:ÝË„ò±Å⎓%2Qyð“/Ä!7¦]_²œ>úá¡÷ùì{¡‰Âèo¬¶ ?^8c-VEËkºŒž4ê©ìkËúõ.+Þ“/;ã-ïAZuS™Õî·,5ÆÈ™€$hße'µlÛq´­ÓHy´”Þ51ç‘Uöê)<§ö8:s\/WÕÙ'‡_^kûôçŽ~ncÐxÑ\~ -_gõsƒ`éXcËcŒ™ú¿öÊ'<Û'ðПÄ[cçÓÎärÎ|hyîT÷Ü— ·òé(;ÍîÆÖá(«¿M)›72WJþ͘K­ó9§…Û\Sv½öÈ«OWº<§{·Ë ,Ç¡AS8É{LÕÏ>œûÑ—V¢¾3y‰Çñ&ùù­½o3ñG.´!Âéš •+vrfÍfèoÜî«^Ýì›Þw$–0çΈøà†ÒïR—YB…YA`Ë·P>“‰_ž˜÷÷óM`Œ˜ ççfêw·  -jN ÌBmÃŒ.ôEúng²`À…JŸYØ€ÆÕ;êM>tt³ k^ê¸Øöï—ÂññªÃÁòŸ åCŒÖYòÆnÎ)%Y%d,`zêu¹¢wm'ìT&Ž0»7âXUqw>«b¦vJ²š$ÇoŒ·¨Ó^º-y]¨œl*н]¥BzðèY»hüÝŠ¢‚²Z¶UvHнOxqõ̉争íeWMD,kA 1 :¸•ÖXŧTzÐeuùºÊY_æd C›µùº¸¨¡4"0švk(’ÞôŒu³O’qÌ}ölÚŸR SqÊíVxxôf)lˆÛ7§ýÌ%=jÌ;·Äçá@Y\ÙàϤƒG”Ÿ7ÊŠ?˜/»eÚ<¦vßίx&+z» d 3CJòDüþ¥0PÇÃe‡çÅã#@˜®¶X­xÜ/ôÖÉÁŠHsEF[D¥K”í úm²¹»SétFŠ¾ak ›#›f°ö$'IO‰L$ͶðiLˆÑ±Η ^ŠU&›êQAèÀºÂp‘=Šo‰òwNQôw丫æº'È,Ó]¿üPf7­Õ%Ùe»"ÛÉW®K·'yˆŠÓ´CxEëÙ*ýGM5Ž^«õºæþxÛϱñ-Ýwc&ßÛ}x‘+À€’§‹ŸžúÑ‚Zs}Oò£6É1¨”,]Ói8sQÄ5›3•ŠÁþâ!E)G³£æÇK^!W=¬Äµ“‹/Í% VtDæÝ?s»É$ ò3Âb?QZ«L§Ž^*¦{?†¶Rfí84Òa=«-pe̪_P,*jf^Ì7F_ò0s#° M,ªàÌ¡ÀÙ~½5%X²¼û*xÌ>²õg#=‘l-¶è™wÊw[‹Ñž‘ÕL’bjEä@yVÊxv-êüô»Dø¼^—®+èaážoN*bŽV»U°é¿.9+LÛ!;œ9d«`ÿ€Œ5`_Øþôº|ûé¡áòÌ#á¾Û둃hj:gÉÊ[Ÿ;,ý¡H´öškûX`‘ÈÁgëw,ÀþŽxÀààœu¿œƒ[Öî@8›$L» ƽ’Òïa&q┫WÉ$êO¸WLfü–€¶Üq%J&TpcïYx®Þ|ßí!òªy¥ãâØü k]Ð~¯ãVÒ˜M!—÷n'Ê,ª®,¦ÚºP·šöfäµFPD9bfå½A°äPÑùÎÄ7­ÂÝY–{ÈÁ†:îžajï>ÆÀÞöu§ç6ë™®|Lq¥Ê ïηÈhÍ"Þløu¦voÆÎ2nñ1bfm³Ë?:[m¬}y“éúÜ©”qc_i]yi |Æ¢M· ¸| ñ²=v°4FE2òÞE80æ?¶Û.NV0MÌ‘fÅ_¿YE®Eòc,G0€}®,ÐÍ,tQAk?Ù\¤½[°™µž}è#TeÉmJhµë§Ò­½^›®!7ÿÊR–ARƒµ2:¨6¯£’ÓÓuýLÀÖ’sÐgyyÔÒgTmKûå“!Š†üXÓܶšß6‹î¤Î¢’˜oŒðœPÇRkjõã-IŸ²]rmë@?3cž÷SºòñKÒGjÊòö5†’F:'õ¡ÖYÄÔ­(~ÄC_M#ÍQ¨ÐÐ: ³v=ð¾"B_ЋþÉ4ýÒŠK† MǽG™¦k[Žsˆðî\àUŽm]?5ÒôO¢2CæÈlfšŸìõ(ý?NªÑJª§~ÞE|E‰û(ƒ}dE>bk¤Í a~K:¼,­o°ZRŠa÷a7;ìÍ¢.ÅH‰¼ŒFžàÆ8À=¸Z§Ä¥Åy¡¹@áë‡y£Ú ³^YÔ«4¶{oø˜}¤UÉ—ç/r–²vv«¤t;‚IÚ‚H\1] iQS¡3힢­Ëš¿ú¤Ì¶5ÜÇÎÖ'¦n’oDŽ0P-Û–ó[ z¤'ñ¾IxÝ{béßµ)p(§Oÿò}Ç™Ó~UB!×û1l;tð.qcùdï¸ç  }+‚.¼r2××´1²Dýª75]w©‚çvTïæM+o ¯Pž¦ž7 x€Í.kWÖÒ§u„¨W´‹¾fËés…ÛPúôîÛüÀ,T—•ð=Å ,5ubÂÈÌ'è'Øg'n¾mé‘3-(SËc ýè{| Ò8|i§X°)7þ´‰Wf1ågÉ “ª€³†=Ù3ßàp%ÓlGrÙÅ–ÅúG!ïî¸ÊÒ:!öT²OSƒHE¥)ׂ¿üCö÷K¸ãqégNpÇÄw"mi-·AˆX(㩧'+è2hîº8¸Ö ‹ ;ΰˆ¯•ZÉQ¾R³|l;á::óï1üXü¾³u°ÕTq3¬T_·¿ŽhZõŽÿ€ª½%4x˜DØãÖ¼0ÔŸ!N_œ­•´6MK—“ÏOŠ" :f¼F‚`ƒm)‰–¢™Éò2u$°ˆë[Ö *9e±Êã-õé#nÂ<VÄL÷¥´Ø?×V`¯Tcÿ¡Ð'^€ÕËiMŸîTµÌªŒ‡w ÕkMw~Ò* ÎoRž+<¬Û_±×ïÙÓD—þÚþ Ró–»üL‰ÿ"Ÿy¯îz˜Í¿Î¿¿»}`øÅ„Ú€tl—ßÜõCÓ—ý¼5WÔ« ØMA~¦ˆ‡ý®`C@6W:õ&ËKLÆ–ïzßvè@žrÄö+´1‘švÊeya‰¿ Hit "wYìݦiåð)N”}b Ä¿ò¤Aâjç—{Ób³i÷ÝZb2Ɉ,*ÜSÙié:‚ƒ ³¥Ñ±íÂÙÑ®¼"I¢çŒûVE3õ F1ý†PñÀ(/r¯ý>¬×ÖÅÒ˜Œ>²ëJ=ÐVZÖ†“êÙ<ö!è9 ¡F~ØŽÃr—¦5ïÖÐ*9€>V´¿ˆáÏ£ù‚e£5(˜Ëð½ož³pp\ièB˜<ÏãšWý1MRÅÞ4%Ç:g Þ£ ­\Ô(× _&ÏÛ]à¢MØdöû 3L&-†ÚCBN@Iƒ¶³à¬¹ƒíÖ‰ÖÛὑáŽ|݉íO¤‘¶äk#:/2ÞZm‚˜fêÂÈÄ•¸ÐBöv ýVZÖ©j›èê÷Í©:Ó‰EùP¬.³®ÏWju¾îQäuo3; ô¹Ã±8¿IøMÓ=ÙZÞ‘–½ÀõKâÈMºÿxqDß¿¥¤îÔB•d߀å”_òBâ¢ZÊœcñ^3V-À~e’DM<$Ý¿%ï R@Jö8ýr߇iÞuG=YÎö@Y™ÛH%/°¯%§Òðgj¹Ah=¹-Ô0kn›l²¦>éΧŸs½t¿÷n˜ú ˆñ™JIt‰wâÝå”bÄs °«YK_4Ù¢°W—§0í‘6~%Ì-SH€-Dž¯èÕV¥ç/ûµÇWãÃÉjšJ Ûx·ºN™MȳFŠßüèëΈ™éa‘̆år=ýÆÎð";ãðžÜè¯ÑtD¯ÚïƒwªÁEkõUr‹|±E¦…ªz…–ÚίEjôR/­5Ç4÷ãù˜ÃÝ®¸Jg•ÙÑÁ·2<å5Nì HaëÈeAâõ^Ù5‡ášbçÕ6 äy¾À›P:Ú-L97 ÈÐMóÓ†Ã7²ŽÖdvW v#¤Ï ìÒŸÏüÒ O͹¾û„$ò©Se?^Ä÷$yÜ7­GÚ™¼ûÙz“ªÖ¥/K°ÈGU$žW»°í®¶AÙÛ äžñùK¢û‘|j™ßº•bTdë^Ö3·U§Å¬4Pâ­¼"÷Ý.þ»ñëåùçºaâÔÆüt\©xÆ Ÿ3¢¹&g¼k£_-_ÿ¨ï¹Ú…hÆ9Ê&Bõ?«¤Þù}3oxÁÝC’þ²Ò!Fä J’ ˜}¥ëþ­K_|šéâÛ2Ô>R>yóÔ¸ZYf}•^Dc—0\¹ÇL-‰psw¨¨‹rÜ,˜¶Íp¥ì½~þ‡´ÈÖïŒLJæ÷KR!¢¼Ë@|†/?q’‘T½W»„Ÿjá,y-¶ ¾“ïþUÅOL:ÜÖõ „°í*G_æåOŸ€ŠÕ¥çLÝ´6LÕ”µÒ@T]x6 þŠ ~’t˜G—Äm,½\ÑÍîr¨~ê²ã3ͬd÷Ä¢^•¯ªóǪà’î×H¬~K2Z§“ã—nÚ’FŸ¨rH»Ç_ynÛÄNRŸi`ó¹ò¹Ü—Äï§ãõÙE‡è%.GÅ>©DfŒªcwï ëãHjqè¥×Œd*½°Íyú|ç!§´Ùô°<à¸Rzq2õ™©y.&ÿœNÛ C º¢4òô.ŸzÕ$µÒ¦ž»Õ».t"¿ÅÓr¢Ç^±7e¹s0~k´Ó¯ôn¹»]Y)§|zߌã½ÉéÙN® I*¢.-Æh5-Ë=…f˜gc‹Tc›§ò¨îjï.¤‘4ë’Zªë~Ñ2Neîñ@DDY¿TSºã5UW3Þ¬5?· 1ɘd#­¬Ñ)KÁPr¶õ›G«5ÿ²Üž,ÑB;|š¡o5û <3é؈ÆŽ!^,2î“~7bþIÎÐ3$¤ –fÙÚüBâÉâWß®Q½Ðåîèédz”~qó2vækmϳJË‚2fSP§Ènl/±hÌ0“lò A00Fö IæhÜn\L$³åü8ðÁœö8+F§;9=uBÏ~ÚG@` Å»ðóÝFªIÛYWc>ª÷Î’é½Q(÷0M%—EßEe(y.U ßvYÀÕ¹õœ9²Ñ~µ+9bizç>IÞA·dB¸Z‡3-.Ìó ʺ!IcãÚ–ˆÆ'.÷¾… ‚.¾Ta¾±-É€x•3¬Þ‚-Ç;BýjŠë7÷Ú—…D[Öø’6Þ²Ñw?@’Bt¼ßhõ,í\Ê´¯åÙ¿æXrêêEÕX&iŒ»øÄRh½©9 è‹nØ¥Ïè×(Òœ¤½©¦/ö,îàÒ'@~ªb|l¬íŒåqiI!|ée!l]Éeþº)Ó‚ÕäÇA?lwŽ¢+k ”¬ZÐpX¢ÄóûÙ‡Qëí‡á›àO~íÕ„Zm Ø·³š·™{¤q»î!ðÞh\¥”ÙOC;.]ãæ¢Ú& L{R‡?§2ü¡—?¦°"’ˆ£N,þñë,¢©Âˆ·d)îK7*Ó7j×JKWe#S—L<˜õøئ7ÇØŠ‰÷E:3u!<ù‹”Ϲ¯./Î÷gMO\Ü”²å…oõ‚R§è’7CLZ=³Æ¤»½’y6†Éip46‘©•®MŽû±ÐæAÙ÷cì=]вÔ™™CõYT\[ìiÌžU‘rýü¬Ð_·IhÊ SÖ…ící­ªc®&yƒÝQ®g\?ëÍØŸ]4l:9\ÔÌËV½snEFE(]ƒè&j&ÿêóD›GE{òÙ+àE²]¥ˆi!¬oH@7ü¥9â>1w€ÜÃ%PÃŽÄK‰ øÔ‘,Ú§ÂD¸³Üܺ4+‘ƤxVpúµŽJw®C”–^ƒñõ1bcÁ:gÙ¹°+¹œß0™ÖŽ}ëÕ@¤tæ!äÒ%Ûº3k@3É.…âÎÊÚä´ôº$^³5ê-™¥lm?ßÊŒºUžP„‚èÍS1QD”Ž‚V½ÑÆöGfÉ ròÑhuíÁŽÉØ®ŠÙ·¼Ãñ ¨Ä"Yì±!K¸i0A‚…*~À3pèYéwüüõl—+¡säèµ~h¡í&§W//b+Û݆^Õ4¢~±ßŠI]z`ÅŒ]4gŠIm¤åo…+aÖ‘qŽËÇI6l÷·-ÿrÈ}é±dŸkI’®Yã\³÷õ})†—CJ ¥ÆÇ!`¼%Ñfœ×)™TSžLSÙùzÔ‡ï´ «Ë߸8|ÖÃã_ùPêq;Q–Ìõ@*Þ#¾·Å?lj`XÆ4 Á•êc 6_9%¥Ä´•¡XOËw¹ÚN׸Ö$%Ú©§ï” Î|‹ÉFSU$ñsKSŽDJ~E¥ÔXZ¬çmB;ÛBŠ =Ï l!Ũè;e¯ö¢f>YÓ/[Ü~ÅápŽÄ-†€ô©_ägA‘0Ê¢«„uXBSÙÏܧ‚iŸ:똋›gg¸—`V˜­á­æÇÔ›¢€#íÒ›ëÔâOm)¾ô)õñk{w©ÞÉQÔª1$'{§t·¢óÙZW¸;ÐÑ™7W@…\®NúÌo­?ãF0(8w«sÿ8¢ ½›çIýRç=ò8Ï ‹º‘·!j§*ሠñy/Üç œ‰ŽÌn~yêœîòïa`gøc£dnìÈKócÕ[àÃÆs ybjÄìÏ‘ â>7Hˆ·s¿E3ã À #5K{$!‘`ïäU½”í|)€,;g‰“ÛÓF«e¬)©ÁÁ(ÊgÓ¾º‘ȘIJØè#ú•ŽÝŽq­ŽU£&–²“ÏÅ\>&Ÿu£µÄ3Eq%;îHß+=¤ôâ*HÀ`춀âÏlšávxãõ¶W&z³”b=&€˜ÐÁc ×\)O¤FFC†wtžOttD£è {70µ¼`‘'sŠ!?ó×æbø˜k/ÐOLÎ@)2Ö¶ ¦¿(¸T¦›–t‰Ò¤áÇ”À ë&q åq°´– 𒨢×}Š…öN—èŽ?X“fcÂK%VªÄ<<…ªÓ:ŸÞy@×Ê•5ÜÁÒ߈rš]YôlÓÍm˜ÞØ«ûÇ-nœ©ö¾ É*TaÎáraS`¯JëVlå=² /UˆTÂkç$]ݤ–P6àm™À™ ð#=×k‰5@—ò…¢§ƒu¥(E3YðNï.‰]ÈslíŠÕgÚ6Ý{·QodÁ:ìå³äTrñ~B+¶stJjí!"’¦BWQkešo¶>z UXÒI#*/ó¯/œ½>æ:ªý"%AÈÉ8þ‘´xM6éw¾æ«¸Òk1sC÷õ™S[ hLn.ë[ë&Ÿ7EæB[Àt‹üJE<=?÷ž¬ìe®‡k–ó Üï A?…gužŒÅgÈE¸>]`l¤"Ýã©$IÚº6̪ÓÝÈMŠÝŽK º\t½k¡ácã.¿skÅêN—jçx]¶@×þ̓¬à=–ÕÏ(%e 6¤1A@šŸóW»vâ˜H¤Á¬M°©uŒk<ŒH‘2œ²îôoj4Ïd·éÏ*ØTó¯ÆO—ûðüšÚ;nJO±&3û9®5Ò0²^¸/¯Oyû½µ>¥—¾TÙ.rŠÀKôíMæÑDǶ Á6|0òðlP¾óO ``|¤i897©O"ר\¤±T¾•ˆbiÒOUR~úVÔmrrøõ›L´C’ÃÛ‡Toµ²/öûÙξâËH $¯zp]Qøòº’C×ñ[= B€ºfŽK',÷îFÖ O×›Ñʯ×ô›ûR.7î@AéÔÑê.ÑPp† ý£ß#€ +…pDñÚaÅí–“‰ƒeÊ—w$] ÄsÜ‘íN©}<ª˜#¨@Èî‹(ëâ+y†÷1S5(œ Yt_Äx9Øžx÷8Õ§.+j Ӳɶ±×ø3Ï£F0g¬n-Ÿ9Eî 1{­ )×’œÜÉ1Wÿ ) Å&fßð'Øؼm.b´ÅInåRƒYlJÜ>Ÿï>½’¥´ž$Cß’r¤ ”èäW—u`ÑÍTÍ]ÄÇÉ, «‡¡ì­Ø3§ú;ǺM,Ow/)öÉ)MŠì©&2Ö¡Ó¡×GÃüUð:5‚j‹œ6?K ‰Š’ËžŸBêz"xy’ÜbÚmdHGLJk©æ‡üв™Z‰€Á)ûœâÒ‚Ý'ˆãO)ë ¨xq2!ônŽ£a¾±Óꀶ÷†fíH—\e‚êšÄä•DÎæT ‚ó ¡³%Œ¹ñ,c10Ñ&K>~Ýh Òá=5¢¤§¦}Ásv‰Ùk¬ªÛV7”Ç(š„¾ù/ÒóÍJ£õ'+jܪhå¦Z¯¯¯¡–3½§6ì^ouQkˆ‡aN9(üÚÕOué¹p&Ã"‘­$z?%¿|)³p’6«Äh°Z€úÔxàN]êeõDé±$îÅ{ V†xL­»£†]çO˜›“çU8<ÀÜE5è-C:?—¬ÒÇ^˜e,rG,µãÿÈrc«$ò(kÚ dVëDãËå…Ê•>¨ü²”£{ÈP÷ ”T šÁæß)u8§µ¥…d* I2 rdB»mÞÅgN%ãñ~®9ÿÑâ ~ú†ýÔàpõa DsÀ?§°ù§ä'ƒ¹ƒáÊm{0IU-OÚBuŸÛþq"¿¥žNa(ì­gH<`ÍÙo.0¹¢JIR!g½@V$E;ÛŸ—x¤ÇIw|¼=Óe ½|î \Uc4jþðªýÛ¦±EcìóñÏ«¬wÞN>Z*ŸÆ&߬ܯ޼U›53 àò îì<éjù… *¾ù±¢¬Ê”;ªLfäØç_Þ»\^°$U]j‰Îá‚îÃ/¬7 ‘»‰Ëú#ø?K»ÄÄŠ/Ô”"š…¼,º£±+äfÈ äNL0ˆª?ù½;QC endstream endobj 269 0 obj << /Type /FontDescriptor /FontName /DTVSLC+CMR8 /Flags 4 /FontBBox [-36 -250 1070 750] /Ascent 694 /CapHeight 683 /Descent -194 /ItalicAngle 0 /StemV 76 /XHeight 431 /CharSet (/D/E/F/G/J/L/N/O/P/S/T/U/X/Y/a/b/c/colon/comma/d/e/f/fi/four/g/h/hyphen/i/l/m/n/o/one/p/parenleft/parenright/period/r/s/semicolon/t/two/u/v/w/x/y) /FontFile 268 0 R >> endobj 270 0 obj << /Length1 1085 /Length2 5493 /Length3 0 /Length 6180 /Filter /FlateDecode >> stream xÚ­“eX”k×÷ AJºsPréAjˆ¡A$f€¡†é.A¥PBJ”î†Ñ¡;”’nÞÙ{?÷Íûîçë{\_ÎßZë\ÿÿ±Îuq±ë” p[¨Ü ) ,(, PÑk „…ˆ¸¸TP$ î¦jƒ„J„¥¤„J^L^\ú‘´¦ w÷EÀ‘€‡*<I”\¡˜@ÇéuÅô°³q€áv0(ÒW äâ0øë†'Àê ExC!‚DÂÂÌ °…:À܈€9Òp³‡$þ C¼Üÿ“ò†"<1¦1&y‹¸›‹/µ'‚à-(ÆÉÿSÿn®æåâ²qý«ýßSú_yW˜‹ïÿTÀ]ݽP@"Üþ]jýÇœórýwViã³Srsp¤‰ÿ†yªÁ| =ÒÎ`oãâ ý;uƒüÛfxÛj=Q2Ö6çûŸWý;©gsCúºCB·Õ³ð-cf„€ù,„…„„1…˜ï?§§ÿ{ìf‡ÀÜ0k!&°A l|‰0û!1€¿0æú >Ç@A78s€L ÀŽ úëQÅÅ@¥¿Bÿ¨rK’ ê-I€ÿK ú-‰€·„é©uKâ ö-atn £º%Œ‚îIRÔ»%Ðà–0zà[zÞFÝè–0êÆ·„Ñ3ý/aügþÁôµ‡yCoY{¸â6€éî õ†ºÝF0“@:" ÿ×%Œsäsøßü¿7CYîã/ .Á ‹ˆb&øÿÚy!P7äß¿f¿þÃö0ÌFB¡>P;"4 n'î”VYô¸p¤Ç“9ã}ø÷戚 Áßs2”ˆúaC(ë>E…¬Œià|K^GõÒYfQ]£ÚgÇœgîeHÅåéàNfÈ] ñøØ/ g9³¡M“y&9gðÞp¡'¾ãªœ¥•äº´:8ˆýt4ÿøJ™`êº'®†ñÈÌžAÞtÈbëûtŒU—æÝOÓûèQ€¬AE1Y³¼˜<ï²ápT­és§û=Þ=ùµe–‹gJ»íèþDr‹¢Ÿù RæT™ZA7ðzMå«LS\Ãò¾fãp0Ñ|\–-I(®|yÁ§V_b]îhᘗj­¶P4HknvîÓ Èé^cíÒu@_£ñµÆWj=ªÆÞ­–沄„¬MÕ ß¥Ø9 PŒÈ+«Já,³«²;KkºQyp=ø9°ãi̳•ÊÓ|›LË芙˜·óVÞ`çZ¿p"‘&“µÌÀ{¡™ð`R¬žûOØ7,¤Ä²ÞÝŒy+¢q"m,¬=‹Í<Á†¶öNÕ«ƒ‘™üô-™?ÞGC‹rõ»çÛ굟†Ô±ŽüžÖ¤X§fuêJhHàÛå«{ŸhÌþ¨ÅG¢E •]´v— Í롤}áõ­ŒÁ<»h.õEi~ý·ë„“_|ô4U÷‹”§c] ¹ÇŲˆ„Åå{Â=©P]|uš7áù‹dá|ïcNxEåP³Lí"~wâ¯+ UL¥O¸§Þ;f(f£d'«KNŒì”I3YwÕjÒ9@AŸç$sbݨýµ¢áªó«øsÕŸ¢9xñTã‡>¯*¦Ž:JšY r OÚXi="?m|ËKÀ+iÕ`j¼á/͉Õ=Ç©Ÿsñ +bä)o’úò­^ôaØI9þñ=àIŸz²„®³Ê¯bø&Ëkòg:j_H™%ÚƺâÝk \ØŸš=ûèàè¸Ò´½Á9 â èH§9Žé*ZñŽòƽO æ(Ûšˆ‹Z¦ MtZ4JÅI°âˆE»ãìnäç¨+Õú8 éǾáñÔ–°y¿>}>Öƒ½ 7¹€{ZÈd¦•L?gZ—kç{ 3|ð xnƒ£ÚîBl@ªpÜf‘xRý|A?vq 2?†‡»ðÅ/%osœ5ícSÄ.¿•“­æ(Òøé-7ò7WFDŠŽÈ½Ï¿·9r–ƒ«>¤ûå¹[’^’î `æ3°’_áènÆ•mu¤S ½³2¯|ü:ƒNŸt®L„c¥*¥Ì;.iYßNºæi‰N?Ü#ë2$¦Èöß@‘­¸¾ í@œžb÷/yú&Ð'õ™”ÏøN ár˜[”•FÕ¦ÒZ~·×`·j ÔP—¹s] ©!Ø+ÃU#z[Wã:-tkí2 }¿OnÆK¼ '£ ì—ÂÁF?+ãúÙ\sRyj›¢Ölæå°)é;ódÑI¹Ä†¬!Ç‹…¿#LáÌȶ;EõÍ):ZY÷>¸6Л¤(j–apó ȱôПõÕØÏQ~¾ºÕs³ëÂ2ÀüWN'Îk¨J™H/ýA.Ë€õ?kâ ¨böˆ–§´©}Ê3pü¥×±‘ò¯êÒï½Ìmx-zçNýxçrR©>ª´×,®ƒ_½‰‰pµÉu„ióÚ1а$³·—³Ìèöev…•µøÏll²æó5×ÅâÀvZÞeUz¿o8¿DñŒLI5òúa»ç`gËéæ¾€N>&õ|k:þ¬=VM‚µipK°Ö±«ÍÃí+ú%1±ãha/eÝD€ÂÙ\É{wõìYð­lãÐ;qŽ³b1¢íh IÄþÓËÙܲg`½ç4[#Áð÷åücÕÛéqw»D2°z8ç®7T€wú³9E6@rO¼¨ŒÍÞûKé­‹R—«0µ²ð•E2Û‡¯ËÓ‹(íÁjFpG[ÇViïÊÎѱHï*1'ñŸMÔ„/D2ì«ÄeÌ%]¸hÿñj÷©y#IŸ‰Û”Ââ…Ì;7ž LI7'=c6p-I,ÿamn­ù»Fë"à0nîW£/QŒÿ,€ *rþé%ú’H,ˆ•[~U:Áý‰%nh›‘rO¨}ÖŸ¿ýw=>ض# ãY–†Þ_dÆ2SÑüìNÎ}¼þ*!fë¹ÜàÒ¥‹-.ÞÕ{©û¾¸/‹Â%¨±˜u§~^l™E!üæò€¨¯†4o¹‹Þ«z‹u¿ä G·#©¹f/Sc’Õ™â+'áÝÙê¦ ;†#Å«h×’¿µzúš0¹;N¡Š³­$dO«°ñp§Xqêº#MPÏ™_Ä“qsÒaÑ<—HCÇ(P½-ÒCÙøR=n é”áy"ò]ºZôy¸Œòìàª\ùÚÖ¸kûG,³"dðÛqÕ¾7©)G¢ u:“韻¥¹~¸è~ 1Á ;ùQÆÇ1 =…Lî3¼‘²uµ”F—ÑFå·ÍZè=%nâP€>ŒçewQPôʱ²2,Å “×B³é% °z¡µä›™êÅX¡Æ »†vˆÁÃÙ­&¬"È÷üuúkÏ_1»=ñøÆL†a?O°[z÷×´þpÕïȵ¨‘mánˆËë“RŒ)6ó¤7î¢$WJ ü…XýýtïKM[Ý!'"dr"mu+lŽ±ŸOÍŽv³ žèÛÚw¿n“Å7TQŸ\šŸ—‘î¹Äº@1=Þ£î\ç× t·6Çjâ´Ðé*gH½K"¥Ì×%¾ ÜÖ—‹]N(ÏÕ×;;­ä@°Ó¢ŽŠg·4Q(ÿbïšV3Âu72.Ì›L)@èýŠÿdgÛØñ"`ùÏ[Ù`ÿÍ}£,CÑ|¤ÙÄÿj?±j/é«î.º½ÑK…§ˆÂø䧕ñžÜõ‹5¶æHþX9%ÍMACÇrùkëR"ëÙfÏ®Æöl¥?»zÕFñ½Í=g%!gµ¾qÿ+bóžnÌÕ+ãÕ·g˱Ôg²Ñsâ´‡•š$çZ–3FXnNÍ»…= ©ÓÉ$©Õ%ì(NÆ, uqĪ”ó£/Cè„°1b8xùN³/iM‚7E).@âí•ý‘¤•Äj&P%ŠÎæ .f°±_Tåçdµm¡î!E„%Mû;¤fŒ±¿T–Oš²ÈÀöD´µù~±ñɨv—±“rmík˜€¼\ÒÃÔÏ ùO‘ÖCGX?IÛŸÃL.å†Kù![÷jóZb꣣o¤u2ÐDÁkþ§DQNg?|ø2÷âïlq6Eûà™ µ"¤²–§ùMDhrÜ謞ÕW$|LÙ¸k){ïëH’y Ш×àNçý”H±ÄmM»}M‡»Ë§­É¬|åó†U§ÀBîݯ™¡µxòË?ÝlgXŽ]¹èÏXè|%YÄÆ×ìâ¡Ô!ø°wGáó„&ÝóYy²íµ¯\~ÀŸÜ÷\~{yo‚”JXÌÆNùnÁPSȽ~ù©ý˜5ÿ‹ó7m·ÑæÙÏ 2¶¶è¢öU¹×øuÆGY©"2§u=åe)ÞÈÛ/•ˆ%¦óïBÀ‰¼T•’,Ê)¸ÄbŒ»žgG=sÇyÃé,ìmùíÝ9kMÝ™àH‹;&zXóÁ*©lÎý}Ñqºìšj&˜‡YçXçÕã–zéÌ:€lÞ#ÓÞí .?QŽmzp¹,›ë˜’×µt¤ È& ŒÐf]=zÙ …°cc·w[œßdKë+F$"•Rp¤b¬ý8ªW ;Z—2zòô9ÄÒO#ê“R, é5û°«çÑKè}½o™÷=Ù?®9ǵ0,k$/&³eTOð° ‹†ZñhŒé¦X™ÆäèLýlñ­‘£ª\„piŽ¦s¾›í¯>ëŸd@‚-ì?V€C¦>µ¶U£9Èü¦Ïì–ù~©Ö¬ÔWÀ/œ™ÌÉ«äÌ°ŒÍ*ŸvÖ±šO1 À#®ÃåÃŒSo¯³wbbä“Iy¿Ÿ½%[6 “qèüóëZ2J)4|°½s!oi6ªLgr×P/=Ž°w\‘Þ¯<Ÿ«Kè¤ØxËík lßKzTúb§`ý9ƒbhm1 èunu*çÞ\Q8ï˜.;Z×ÊáºuöGù‰[ ŽÚzô¥sRÆûÞx ­¼ã»«¾æ¡<ÅW¤Ÿä°Ô/×=vîsÿÀ¹9q[X"ëïõ»áÑzÎF j}Ä'ˆ¡8ðrîuR>ÚÃûF %§^ÔÑb\T3Œ›š$ùõù´ ù¤T1ž®7z]V½Cò€}„kصPõjä\½«{ý“î1-óÀë‡à•t"â¹ÈDè9 ;ê@7Ñ¿Ux¥ ¸Tˆä±|<-ßdë¼h|u²›u¯3^,:Ÿ‡€§ÔÈÔF­ÚööÙ}<{ÛãÒUéC¬öƒËVæÊg0ÑLÆI’x1¨0†1ƒ¬`«A}1dkF]ïÛ,)à3ˆ_ßSm<yê"ÝÁòkå•Ô;„{`€€¢§NiFWÞ’¹ä±ö[&ýø5iɯsú\ Þúë íwCîØüúÕåvm`ï/™5=çt»E3ò½3›fq¿ñé·Á ïÞµ!»žnÜU±üx™¢‡M·8ðæÕHäd÷oj­S>nê7êZÊ ö b>ŒEѼ‘7¡ÁCjTB[³´%”³K¤“³Åf¥yýa =âŸõõ¹áiñ¨bÏ—»‹l‚$êÝŠÓL{‡L_çt>ª±Ç†eÓí¯M_ö-G÷Þ\õðõ¤DÒ‚%_ÆÔí[§óÖzÕ¹sÏUR\oÑYwÿ&,U Ð§µi/ªÛdN­Iúî›ØÜMÇÖÕªX¾ý¤²¡Ëå¡Ì­ÖôôfeÓ¼ë½ñðMpÈuî¶JÃZãP^5µâYË3Q©=†Æ‘"MX ·„¹)Pq“?,Ÿpˆ»Ð¿¯"ÙJ~¸¶tê³.G£‡ï€Å°-ÂÍ$…¯ª>¿ìwJò3ܸºþ=ù É*çŒÑpæ›âä ?ºÅ|¬K ‚)æÓC~’žÏQ'?ÐWó˜ ÙZêËu~,"è‰ÂQ«·XáÙ°«VÜî·§ ó%FQÍ3pGZ+1亥 ÖÐ.’$Ž0 Á}È1¹²-‰à=Ë7›ùËœÜ4tY»/NCcF܈îþ–_MŽ ElšŠÒüÀƦ,C½Ü‹k]ò«Ä)ͪ-S/o/@PÚŽ]!d‘ÜïbS¨w(\RhÃ]ËŸ?šèÏ8xFÜ]ÐÒ­°ÀÎ)õ°Í% endstream endobj 271 0 obj << /Type /FontDescriptor /FontName /KHAVLZ+CMSL10 /Flags 4 /FontBBox [-62 -250 1123 750] /Ascent 694 /CapHeight 683 /Descent -194 /ItalicAngle -9 /StemV 79 /XHeight 431 /CharSet (/A/C/D/E/G/I/K/L/M/N/O/P/R/S/T/U/V/X/eight/five/four/seven/three/two) /FontFile 270 0 R >> endobj 272 0 obj << /Length1 750 /Length2 576 /Length3 0 /Length 1089 /Filter /FlateDecode >> stream xÚSU ÖuLÉOJuËÏ+Ñ5Ô3´Rpö Ž44P0Ô3àRUu.JM,ÉÌÏsI,IµR0´´4Tp,MW04U00·22°25çRUpÎ/¨,ÊLÏ(QÐpÖ)2WpÌM-ÊLNÌSðM,ÉHÍš‘œ˜£œŸœ™ZR©§à˜“£ÒQ¬”ZœZT–š¢Çeh¨’™\¢”šž™Ç¥r‘g^Z¾‚9D8¥´&U–ZT t”‚Бš @'¦äçåT*¤¤¦qéûåíJº„ŽB7Ü­4'Ç/1d<8”0äs3s*¡*òs JKR‹|óSR‹òЕ†§B盚’Yš‹.ëY’˜“™ì˜—ž“ª kh¢g`l ‘È,vˬHM È,IÎPHKÌ)N‹§æ¥ ;|`‡è»»9†¹kCã,˜™WRYª`€P æ"øÀP*ʬPˆ6Ð300*B+Í2×¼äü”̼t#S3…Ä¢¢ÄJ.` òLª 2óRR+R+€.Ö×ËË/jQM­BZ~(ZÉI? ´©% q.L89åWTëY*èZš 644S077­EQ˜\ZT”šWN+Àà€ñÓ2A˜šZ‘šÌuóZ~²uKÖômm+ë\_XŪÏùóÄÚ—7ÙD쨛™Rl:/P1½dÉ«…¶öϾ(á•l=U¸h‹d¯_OÜ—EÂk¶v-X1¡Át¿Þ`ñÊæ®i¼ÿ´Õ_y. ›1§õ‘´Õþ¢Ç³:•un~Q®?Á3/å…SÔâ}ßï]ãÒ š¤¥$e~sû]F1ñÊ»Ï/ËÚQ?ý¸mò»³·|<ċݺÔ/¦Ùq'}Iüö„+6­ìâEíÀgŽ¯¼xT.‘òGÀ¿gtÅÙ¥vÕG‚—U|íª“®¾~ª€]üRÇëÞ…_kü9¹öË:½{ápËñGúý îûd}dN<6Îø-uBÛošHºÁ=c¦MÏvHžÎzºq½aûÿìRKë~,KÌž³}Š¬Ë›ªÂå»m¿‡Š÷Öêyo›ù~ÉîÃÜ×v‹ Û_¹éÜÿs>§ß¶.#ßҭߦíÈè{­/þô­É™kÜ—öÉ\mü|¢Ðr¢úÿXöÑñßϾØad­j|ïÇéÖR/ü,à endstream endobj 273 0 obj << /Type /FontDescriptor /FontName /GFAWRG+CMSY10 /Flags 4 /FontBBox [-29 -960 1116 775] /Ascent 750 /CapHeight 683 /Descent -194 /ItalicAngle -14 /StemV 85 /XHeight 431 /CharSet (/bullet) /FontFile 272 0 R >> endobj 274 0 obj << /Length1 869 /Length2 2780 /Length3 0 /Length 3364 /Filter /FlateDecode >> stream xÚ­’gXSÙ†ŠBéE¥ª”$ô" ¡ÆPXPð†äBI „HA”*½é‚"MŠÂÒ‹ÃAé½(ˆx#3óŒ×ù{Ÿs~ìw­o­ý=kmiqKkEÉ4!)Šp%¸6`ˆ²1ƒÃ¸ †€HK’A …@"a( 6×ÒRL@Gúþk«©kÃÕ!Ò€!É×Lpr¦²†rßE€;H&`1D…¡8ƒîôXŒ`MÂ@Š¯`àæ ¿WxhÐ $SAœp,pDô»'3"žhüÆy{ü¢‚d/º)@öÀ¦@7‰#Ý|ˆ‡@ÍIôÛ@º—ÿ‡­Ÿ››x»¹™cÜ¿·?˜Ô¿òw‚›ï_ ’»‡7$($–^ÿ4‡qo÷Ÿ³fŒk@trE¸ªLõÏ8ÁË„àâ, ¬3€Ç¸yqˆûÙ }~> Ffg/Z)üµÚƒ¤%†@¤Øøz€ìõÃÿaúÈà2Œ>e8]Hÿþ>Ùÿt™1KˆN€²š:€!“1¾ú#¢“àDè€>tÇP%"‰B/è“ ð$2äû^é«b¾‡N¿ þ€ÊÿªPÂ?H6PÒH{ü€ª”üÒk½~@uJ9ÀÏ ùø+ÂÕUEe5Ø÷NꀖºVÀÿ(±Þd2H¤nÿ<ýkÏqFÆÙ?fa'û´w£Ù†ðE³ÝG=q¶•Ê»Cª·(‘C9=ú§{ÄœŽ)ÜÈ~½ÛY½¼*°UÝË AI\>l“€€ÖÛ>Ÿk¢e0™ ’ýÚ5ZXvCÙ¸•lûý5nå![”t§miÖ2ÍØ£ Ÿ:.ÎÕñ…Ü´ÐhMÛIR¤|\<LökfK?«ýÇa‰gÌ È›-‰uùnTjgï÷;ùøÚ/xf˜1Šc¤ýÄOÓ»½çóâ5†¼˜~àoÍäúw]×â‡æŽR“•dbP#Ú¥ÓJ_CÚTåÑ·?\,”‰CoÚ7àЕ™Ã(w¶cqQé¿—Ê”Ý^2•:,¹sqš¼Ì:ö &¬×Mū׻¤mæøئ.+6õ%¥FuíÅr¾Ëä5¾îñðñù…N)Ts~Ãí{{"<.‚°|Ü ÄmäÜ…,5*ù—W›í‹X±Üã×HiŸ¯q6WT0dÛ•ì}bŸpÅ°3^JíeIùêg–õÖÎ;ym„Z4ƒ;äÒ¤kñN ß¹}³â²pEœj™Ê9lT®…\ãŒäû]ìARÈ¢-8ød:¸çkÏUý‡¼*šïÔÔŽÎ=bÞ[fŸæI‰Dô,¢«ý}Ç°«¬!a¢ÁX-—7g„RãÇv¬ Ãð«OóhÇnh© ¯­HÄÃ" 4®xmÕOÃ묜U%ˆ%ž„âmdBÁ—áo»4À©ò3’Š;#Ïf†ï@ÞuÆp`Müƒ[ûÊvrMžîåslê°E,¹`+ßp)¸ï˜;žŽ’âG–´»*H¥.7ïj䆦К7–ãK”§^DGéØKÿ‚2̳~u¬)åw'<"‘cû;Û#N-Ab–¿v/îmùÆ×>í æÒ˜SˆiÑ#¶nÏíbŸº‹Ì8¯P x7J?ß–I¬F,l™gô+ûŸ¿U>½V˜+Ý$3Yž½®ë²¬òžŸ Ó 3ï⌧ Ÿ9ZA^÷§0¥Ëó.¢%<å´jÎ3p`Í/ŽEòFŸ NÊp˜oŒ˜åö'üÖ|×:Hr0o!\=àSS!§j%Ê’Ë0~Þx.gß:ÓaÀç®ã‡´^»¬ãOIËN<Æ¿^ŠWOò-‹ðà6Ó’<שã‰Ê8Ú:zþI.áô‹My¶©¸N]w·TMÂЕDؾ4Õ§y!íÕ@±nÆÞJ .]:¿jÔYÝ=:uÝöqÔ½ÂÉ¥BL1ß¼B(=ª¶‰‘ºÓ¶¥0†ss0ø÷?Öl*º£bN•Ÿ:½N8žµ8 [›êÊݼÚd7ç‘–¿&ß.o'Þv_iºÒðÈ!G¤‘:À¨bÕ,zÙ½# 9~N UmPŠXR˜½ýÖ5°(’¥O3’}ç‘÷gá3(Nmáž«~z' VŽ¨5ï8S{ËCÝ6±;«Ÿ)V^xˆÓùLª_郻¬›lr·úRÈ:Àãs)¼10×¾…§J|EßÅ\Ïå7éþDCDZÞy‹»A-±¸Í”Ä¿–_š0¦1¥–ç,ÛzôÖà›]Ôýpàf+ÛÒNÕãìÔë‡ÓŒñ"ÞÕv+z57Õ}HY”d}$Ý#q÷sÇ–#ß›IÊ”p·œ`»™ÅÁÞ|UÛº5´´`5 •9qã–cëÐúÅéCQWŒõ¶ªS»;ÞÅNNw]éT®ò*XUûê³wÊÕl-+&C´8¹&‡÷®kÙËLñ’'ÔìZ{ƒì]±ª%¶³þÒ¸ô‚ ö·„m»¢­¸PšSé·“¿ÊB¢àá+ÍîB9|‹˜c÷:ÄøÒò{?'ï¹D_•5HÛäQ1æ7V C¿B%}WÀv î¨ ‘²ªšòÚ"¤úú Ëë¸/ýVâ6ǺÕ?˜Wæ&ï®ù*ÔŒWL7–Ñ Á«¸h¾§ß>ÏU¥g{ßÞ“.âÛèẂXÎ^Ú†Uh¯ ¤æ÷Š™Ö–H¨hî€Q.­ËÒ+‘èéyÙâ†ZnO&þ+z 4£êúÆŽ¦8Šˆûn¬Ö,<{Ú!“a)âÜŽŽ0¿¿éàoá‘;;=w áÜ­8ì‰W}¡\`%)c9Êž<†afª¯YgUèëÚñaûrMq.Wa{þ=âxöiú]@y€ôšŒb®&HºÆA½Ë›+@ó3‡½ȶ Ÿ…ê+‹žþhr_çò|ÙÌó•Äúì“G>ÊÙJ±7 oܱÅø•$\”œÏÖSáËÒ*i¸ —¨RŒŠ/ÜVåO›1ºü@Õ¦MãQK¤¼ *ñÕ¬&ôŠ^§ËÌ+›ÙŽt”IPÛgá4’àr¢ÎChð·…iI3vÆy³%£Õ¦BΔGqÛØNÿ¥”<}Ö}O?£ù…Ê^˜É³3ÊÌöÁú=¹!È5ßPHkq ôˆÚ½8Ĭ۰‘¸ãGɼ2‘K}m)†úa¦Ášø ™‹BW;5F $ÕÏ©¹²BºK‘ãà ÆÒŸ"l‡–' åDÛ^¿| b|RŒsy?-ÝAåMê®ü0q~üúF5.Ê }üBx‚°¹zâBKì“èSc¼Ïçx“}-ô‚ûIquÌS±›]A¢ßT  Üa‹pux æSÞËkyhæ_çDOQä5õ[<Õ‘¸á›ßæ©Ùö2Ȉÿ$q²J÷ $ˆÞëê¼û\”¨õ@¢c÷—TÓšvSÒI9SÆôûxÏ/Í–,ˆ_îßh+C+œÆ½Q¹ÜÂ/ìì”sü&QQk¯×—+Ùn%,>pyoaå-\±©±[¥~Ås8£c€Çpl§ä""9kX049ÇTLÊmM7ûΈ•M“¥ºâû5="¬;õí_&ãJŠ,^LZ¥Cg窡Ñ3dv÷~¦åY®¢³º’×»4ÆcøÕÞï„’PSQŠ|í!º×:HE,È9ü+¢fK'Ãà¿›ù~Q endstream endobj 275 0 obj << /Type /FontDescriptor /FontName /DIJEXQ+CMTI10 /Flags 4 /FontBBox [-163 -250 1146 969] /Ascent 694 /CapHeight 683 /Descent -194 /ItalicAngle -14 /StemV 68 /XHeight 431 /CharSet (/a/e/f/i/o/p/r/s/t) /FontFile 274 0 R >> endobj 276 0 obj << /Length1 1956 /Length2 12165 /Length3 0 /Length 13234 /Filter /FlateDecode >> stream xÚ­¶UXܲµ‹»»Ó¸»k‚[p‚;4и[ÐÁÝÝ5¸Cp'¸»܃Ãéo­½W²×{žæ¢ßš5çUS u1sS ´ƒ½+ +‡ @BQCƒƒÀÁÊÎ.ŽDC#á 4q9ØKš¸œ1Gg'/€ƒ]›ü‡DppôrYZ¹è%þIâˆÙAf&öEW+ x 3[€ºƒèêÅ ³µ¨ý3àt:»ÍY‘88æ 3W€)ÐdÄö'9{ ß¿ÃænŽÿ;ätv›ÐÿË&lÒÜÁÞÖ `´@bSr«Á^þÿ°õß‹K»ÙÚ*™Øý³ü¿:õÿŒ›Øl½þ'ÃÁÎÑÍè Pt0:Ûÿwªðßææ 7»ÿ•s5±™‰Ù[Úìÿ\¤Až@s«™ÀÕÙ ø¯0ÐÞü¿=€;÷/lâªjªÒºLÿ³©ÿT1Ù»jx9þgÕ²ÿÅÜg'@Ü_p"øó¿ß þKLÊÞÌÁdo àäá˜8;›x!˜xŸ8 {s 'è 6ÌÆjïà ž÷Ä`áàŒôÏŽòòØÄþ ý›xÁžÿ€MâñØ$ÿ€Mê?ÄÇ`“þC6™?Ä `“ýC\6¹?VWøC`õ¬®ø‡ÀêJ¬®üâ««ü!°žÚë©ÿ!n›Æ«üC`uÍ?V×úC`uí?V×ù €ÕuÿxžÉˆ|QÙL\Ì@ W­9ð?qnÎÂ࣠r±ù3,bú‡À)¦&f6.¶&.V-ÈýOØù¯¸@Sg3 -ÐÂõ¯0Ïÿ„ÿ}ÿ³*Ç¿Ã6@×ÿ“/ÀõŸøM×jöâ[4s°_ýÿTÂýOÄÎÙÁ 1ÿ Á’*çý‡œÜÀ·þO¸R‹?ÿƒÛ_²ƒ½Yþ…`Å? á×iååh´ÿ+ý…à=°þ Á;dó‚KúÛ ¸^»?¾µl­ ~"Ùþhƒsì ƒ½;þÏu4qÚÿŸNssüOôÿö™ ìÊèl´ÿ+•÷_1ßnrƒ{áhëæòg¸Nn®@sÓ¿ªàGÿê ¸!¦ð€m»í@ÿµ‘`ÿuÖ8ÀúÜð€»Z9ÿÔË.ÐÕÃᯠà5Üþ°ªøýqv1spþ»KàŽ»ÿ…`;\ð¢ž!XÕë/wØûgðJÞ@ç;øß`qqÏO,ÜN.ðÃÃ~(Ø}ÿOš™›3x'\ÿõû~Çÿ—-@àGôš!­,:˜ [§6)÷“*œ®€e„·l‰Sjè™ëDZŽ‡´-ù®àĸY¯ýø5íö€Üã™Ø%¢ÃGuBú<Ð).máõÀÝø ûXû*CÑë‡#å]Ð1ú·æù›HåÙͱò$¢Áì‹¡ã|zIŸðë½zî½™Á¼|ÚÒ¶CCêi¹(Ô0ÒœÊøC7<0’`6¦‚ü¬CZ™Ö.:Ü° ò_ Ìà"?sŠç,·LY‹„f°òoèKZ>lD JºÙhL3«{Ó«#çÛíW¾Ý­vO嘆×õzAÌ?ï"š2Nþþ@?-à¢u ÿUU æXPª¥RÃƺ*H6„³Tê?é]¦ò))H·(•®¬ÓûTa2ˆ¬ £9?eº ô¹Å0&¼ÝÇ\¹!•x%Ù«t‚¦ë#?@•pOÙ!®õŠUÃuÓ}ð†9•Š£¸xâX0лMŸL³ÏCóD†×ãG?Γý›\ÜÆWìÈ%xÃŒN=¹ºâag„…?w†‘â(Ý+ÇŸº§T6æ”z¿Ím&s ôèÚØà^£,t¼E—æ%X,ïfƦ.ìh$º[]_ϵõG¼} ðŸ'ÜPÈkÀõÓŽÞÖ„ÚR% Eïxâøð”ì¡Õ'CÄl)yC†$1΃Ì,ý¸O¶T‹f% åG{>o>j¼võ=ƒšô!|~—[˸ê¹îä+ö:›Na¬–/”¡rªÀa·ckÑy[¼ûì/ßíõÈ×aâ7Wñôôcù¬(t“PèŠm€g¬ °šüR½B”̬jÄÓ»ALºË¥ÐÂ!hdA ùJâÂ=¤–®[]+󟬌q82"eÖ¾¯¢ÝQ²€ig' ÊA¿-3ÿ,4Zz<‘F™ /=ŠO/úéëh¬ªS*¬­µŒºNMb–2ŒÓºÑDú3cøA,}Šq%ŽK))ÓMvQ’ìícØõ§J‹º«&å²Ö¾=LcЪõ3 Ïû¤Jò&f¼Â¥@„›±ubÕ#dÿäΰoŽ“i¨P„ÇxMâË?–š$cq…›ë#áE²BÅBŸ×6½uŠ(ƒCÒkOu« OßÍ™~’½‰0¾ê"gVÔcr“°3ÊØök5ÿ¢Ç&ÆÎÊûlcT%éù#Rµc2O`k‹$©ö«¥¥×ókÀž8 Þ ±Qž‹;Ï·¤Q‹B3ê8Å'ŽZ>ydh¾·žÀ$ºl+ÇT>+s ï¯P4`˜Ÿ_~¥ñ…ÿ&jÈ ¥x*¬ ¡tsŽàTzï ýxѯ‹þ¹}úKQyÔè /á:öïãÂÀvºp,©SPz¦*ŠB9Hé°çë[˜gœYDö£RnFƃ›YäY-Ì—Íàç]ÙMþ œ=ƒËåw…›„ÍJæxäH•K6Än¶ûsɨß ë”!Å'ªÅ Ð]Ðä“ð¸à Ûº<´R#Ly•<>› Ú § ¦ç„©KU‹æPª¿$èKDJy»t-ÆñöÌ—¿Á × ·fHÿ|Ÿ‹6±óÛ’­Ý<éþƒC¦nçpƒ†É·˜wd³©V6Ê9Ž\öÈT‘y(#NñÅøt]åd¶>’­ŒÉ 8}*)¢“’EÚy@*ÿ‘žÃÑõòa—þ—¨DЙâþXÕ$¾¬´œÚd2­‘ˆ”¡Åú†E§Ø¾-ˆb„Žáöã*ð˜™W*Mªò‹ °¥Ä=™)ý„À¢Â°,Ö9ꡇ~,þÓŒAoS‚ÿÅóå5cQw^ìé%ÚÅÞ£=ö$dâ79&Í ½Á/ga¾¶k&AiÏÒ^…­k0EcÅ%×áxŸb´°%ÓXŽVq‹*%p;&/`}˜%m¶hY –wöu0ºWŸªqôŒÒÌ_"”jT³O‹m©p+2áQœjŸárnÔ¡‚ñ}èüõ!¸šÂ%éä=öSÌXG•PCŠ}_Ûb¡xÔ»¹Š½—¶sïÉí¡°"¾a‘­©SiÍÞlþJ‚ 7sF /o¶¯™y€‘RíéÃ$d 2L Þ–ÐîQIOx–©ð4M›CýCü]>Œ²ð •ÄàñY¾Ky!ß»M”]51¨ •å¥fZÊ~©=\ U˜ ªjµ®er+ó ÝC¤¯ž_–è‡îÝ~!ë8o‹9ŒkOß’4{é:ßV vÐAIXáX¼GF·àº’Žžeµ h ÏÒ¿¸V™GÓ%HÛ}߬Ê7<¢:™dUVîêÖi w÷-@¤ã.×ÅfØîU7ǘ¯j +ì0Ïå?tç…+´¾¬åÖ4Ky›³p8µT×Û–³?°!AN†ŠDgø˜éq¥Cn)uÞ Y+$=êì_¢"V¼´”iŒ›ã²çmÍ·2ã ý$Ç“­LZ RU{ÕC˜í›« ½EhoåoAuþÓÒâjª‰M5Ô ÛqGÞUs]½d™éÊ“”Üþ^ü ±Û¢{OËžÈf)ì-a/B×ÈuÖÆ‚¨Š¤”/R«žz› ^9µ™áÈ8ÿÂ:•³W½5dSY+ƒîŒ;:+úev­âQSº{”Ðíˆy|i$̭ï&ˆœÖ×RYNi°¨ö·l8§Ã7#žÚçÒ‡Üb]äÊ éÔi‚‚ à\e7q‹í“BñðwL3‡Ž@³nvRãpœÝìꉉtf²íÒo½ie¡k¢ðm?ý ¾ìæ¸[³ÕÐgë¹Y*#yt¼ì)[jqq'$œù©Û¨§Ù‘]Ó SR’Áé( ÷3ï¨%k}åäÇÈ®ÛźWJL;v&>ľ+ÃmÅOâ¾qA"ÝòB=™Uâ1Ã(±xÒ•„ª‡Â![MçÓ„/aöcuÐñÓ¿î>øŠhqTÒVãxF‘LÐu†ôJÒ+Òvþúü(v„Âò»Ó2®¸sYwu.ƒÁƒ½•æ|¼Èª§N­³æ·'yq6ìs;À¼ ­ŸSéùJ±ÜG©5^6¶@—y=ûîÙ§ðê{KÚeZgsruý”ŸÏõœ RY>5‚*dš– ] ÷]Á>Ò½á`Çdß÷!ßs­è±`ƒÞ×) dº²Ë÷´]c¦n©ùo¢™§ü¾rAÞüÈmi­”†Üúã–¨C©O{Ø»«Ÿ4Ô%Ò3~·*ò–ô=é#C U’Ò]ªÿ5ÜiÇÃ`NIÙ Ok¸Ã°e±ƒ8gý#Ò’Ú.q²Ùµ=UF)hÌ!®ê¶´ãô ‡¿ËLºþAûýãiïû™Ží6¶$Ñ“ì eëB(!K>ÝÀµâ:q¸cE––vÖˆ×JãLN¹Ñ‡ ³8±[ƒÏý$DÉ‚r[µWú tä¼,²1Ë8pX¡ô9Þqöï d{ >PÒâûo•¯ESì‚hæº5/ÞÉ¡õWHS¿;Rôˆ½R„q˪U׿˜° ­b‰îædñòŸí`—–ÂBÈz³+2{Î¥ìÓ bæ "ZˆÍËZdTÑØsMC‡!j]¢f¹Š¦Žž/Ò·íÒÞÝšê±³:—@¾¤Ê5òTˆê„ê3Ô¡/m’t@åm4* UT¶oMâ»2ðò4Ó$´\žá¶ˆ_Š–D74-Pv¾ýHuª2Uû°IøÝî ´DJ(is§É͸l†6¿Ñ.îä·xjfÆ/mU4ý´,€¢öø[”~/+îDÉKN ®m£† …oºî…Nƒ†ëÛ/ÃÖ#‰r@8cÒsžë0áa³[-dà]¡¥N)1ŒSV²: €Þæ$“(šfE˜\‚'” pÊ2¨dŠ_Ùû°D%Òh¤½­Û1¢Èaƒô©5Ð5{õñ™4¨^€[)iìeúÛ‹Öög|;=Æy•Å÷³÷¼•´Eoɦa<4{ªÙì¦ï¶ æ3¶!Ïw[]¼ã!z7ìŸìF’µù^QBô2x‚kì…9ý;PÐx|‘í+‹Þçݸ™ð,HÁ\X¶Žtú†0suE–TÿjÌûµUFà¢éKñ$¼jŽV³! ÚJªˆHV}cýjTnɨ"_ XŠ¶öh±‡ñôMòô´…ﾦÃ4/5¸7œÊy?¹¯&²“á:¤¨“Ö{¾ëð‘©D'©2>â)iþÅ ªÝ­ñäFâ¢Ù»VAö:NfQß-%ĸ|Ç÷îéàÐÿKô†kz#¦,…œ¡=ºjôÝ÷4”ë@—(UQ…þGqÎPK¤_ɨ×&¡‹¿+à¡ÌF«“¿©’À8E›—24|HÞ›íÞ<²_±c^ýqš¿WU&ïEw Úéã¨ðÒóâ ãBH‚n¡×÷%ÜÐœ¤`ƒB6SKâ°Ÿ…=ŸÉF{ !1*·6åhGM6?xÔÃŒn¥| ûì²½öãë§!û÷ÐU>jšíþ°V+*Q~IÇ´ÜI-Qßû¹~$ÅÌ,š…¢H¼J„©Ô°ó«é¶{ß?©4N¢Š¦]˜¯fqiÞ«tºàÏOkîÁ _¿åí~ÝmTž›Í~Œ8U¯’ñBÁcÜYçyИÏßßåÛŒËaÝôxÍoä€l1¶ `Zg©)‡ÛJ,ƒyÉ-ˆÖ áoŒ}Tw“!åýŽ¥—£Å7Qq¾š$éªÙËmOyúÕ.¸ =,…T2Ī?Zÿfä$š&â™De?²Óà6mAÙ32ŒÅí}“ùiZmOCŸIyóÛz©N—œÎ¯ÎÜÊß7g Xîm̾’#‡8!XÃB!ay—ÎÊæg9øËö¸¤í&Ǿs6u„ÝÄôg÷sjzÆ\’G³É$ìeõ"%@JßMçêãý%wú¯Ÿ¬ÞºL±~çдìöeŒý&èm‘ ö±xD}3øtªôùï<œ×‡áf&ì§Ó´°åS™„Uõ OI»Dð±“Sâ,f]÷§úz|³µßÇWÅáZ1Äá ÞLÄ¿‹Õ›bdX¼Ò‚Óé?íèúúƃøá,p×Xá}ܽ‰™µÝogÒhØšæÜâ`d’SW'ÙÀ0\èóž€).ÅQÐÊȹ!¤eÌÏ2O‚&Q¦BL@lVJ2~Oñâ„ûXÜŠwÍ*ìô­æ»Œë 'ÄPånh€œŸj®Œ„ÅÃ5稟û¨+Âc¿³èqÈ/Ä÷?²{Uw{Ý!W }¥4D@pëSP‹¡` d*]ÎÁ¸–ýÁõYUõ ì\¸L¥‚†1ëòVŒ^ÊhôýÀNÃî“Ñ.®ÿŠ I’±~½ÌËûÖ)uxT.¡.ãyZª2Ö^RU3D$•-ñÙJY¡ÙzÜ ?´+_›E†FÍ®â“`(…¯+µTî¦õ*Ò(nƒWwÀID¨1¡\d•ÚGlϽä&NCh©q_³ö¬ÃpR:úØå¤%‹ø-n=Ë9ì\8ZØ“<¿*Åò =‰÷úéuWãæŽ~ž®?éØK£÷P†Ëq‰ÅJˆ —{#]aiÛÁr«GËÿÅk/¿œ¹r—Œ-O0ÿœõ› Â2”øÉÝ{i£íd–¬Ñ­J ''î¹Ü\'ê‡`…™shS—*â>’+Ä„G­ }Ç.à É(Ÿ)©óE3h•OÌ_ÇÜÎœ)(xw|rVkü(Zflz¾]‹Ÿ¤Œ[C¡jf¦,ÙR¾n<.ʱ[ntyßb„[1”Ï}m)…Üw8B÷ |!éPt‡¯ÃE~ßXýMEèõûWgõ s*òûé ºß°ækÔt¡eöf÷ÙD–¥BhG¶ÊÖiA4Pµ‡#íø d/—¸IŽndnI¶°úà†àÌEseY´êÏo&w¿«û)@ç*¦2(|~ç&Ù;kŠek™ùÅ vfe’vî ÉÆŽñ— n¥cý•ãƒ=`¯vm*ÝMì·ÈÆ»#wx ,.”=˜jŠ×üjMžÖ‰¾ÝÀ*­#É€ººõiO@F}>õë²Fz²Ë }µt´5„'7Žû¡À‰k£‰ÎÏáEÑíÀ鈻Fq¥ÁþVü3÷ÈW>"ìrìñö³& E&ͦÛZA2ŒÕÀ«W?„¢4öÌZ#icW 2·£_^ů!ù…LÖ ñ»ëûèÞOcm'^5B©9£ø;ãx7.Ærn6»,)hñú;+ð¶L“Ä€šQ²^1_R(dIŸ056h&Dnnfd£ŽŠ–yÒ ÛÄ[¿K>†õ÷^5´Ð†mü#ñÊÄÖW¦ÚʺL6BŸ|­¦×¿5y 2Ò!´M+nšð44•Î! OбnZ%"ÊeÇ-”;Àò8&CÞhoþ=›š›¨Q2Pµ™—Ëç²J"ÉÑu}­w± +}Gsf3hƒ•± ºZ_™ý~ˆhÞà¡Eg@„[¯¾Öd®™(§ª_ß •Ô\nKXr”HôèûG_%IçÒ“üÞMl«щz4Í¥ú§B¤Ð†Ù9Àªô %áï¨WÈ 1iáÑ8²iAâ™_zqÌRŸÆ=ç8W¨"ˆ­ˆ¡È©_w_Ë·núOrKX$$žv§©ºDäØœmØ%8H;‹]´c²m¡úcEbJ ¶SÚxv_n¼}C+=ÐãÍ’ÍöÇ^iÆÑZá{ˆ)‹ýçä£!°7ÙÊ趤ࢗ¡ˆŒmE׆嵅Oc>ݦ·ç¡Œ¡¤ãmj¿Ã]‰OÈ EN  —ÄÅOÎá–Qˆ–¨¢tÍZw߆"%ì]͆éî-Ûº¤tg=óføÚG‹ tˆFlÃQÐ- É -ÒÊ¢ò܈¾HzS&ïiI J°f#eb Œú~ HOY3¿–»äv«1†•¨ † >e< °T:' T¨4biç®ðÙ&únõŠµ¾ÝSjHY+k{êÃÓIàÊß©µæ ­Õµôëä‰@Mg°“ïIIMó—ź1‡àK@ ¾~âÞðs>»ª‰-ÆÁ¶¶š†`¤R?Ö ‹…ŒÜÁŽïÚïy¶ñ{!ƒ¾‚›¬›Ÿ“Æ`IžY©JÀ(/ýq\ß@"7¶:œ"YËûºdn¾ôRâ¼SÔ¯'ôÇ Å™Ç*fÜ·Ïœ¤2±Ò3ƒ1Ë|0Øï³Ê÷~5þPWåƧxŸrÕâ}Bÿûtyþn1V•µô€>‡ÒžÚm€&óï¯ÈzÉü“ÁÍò”{z¶Û­´½0˜_©ýLbÅ ]«F¹Ý%ÅËogkrÊ”TöXz‡ÏìM1²~£ÐEš?aÛy‰Ä´Ø± )õˆ²{™u^ÇSª ü4Œä¦ó8³#ßc#T_Mä8ïÁS²xÑ‘êíÀ‹aP7Š¨‡Åv’½žs;Ó—8Å®=6"«ÒH=g¬©×D!ØÓ rkLŒÉÛówY0õÄ¢Ÿ‚~â-Öš GMÞ´éNž­ZNb¬Öy®PÚ®ÛfA,Æd˜ ZÎa,>Vyª\¯>ñÑ®5A}¿ÙHâmöWo²OÚˆs„ ø½ÍC\¯@½DáÔE]iÃì%”@I1‰ìÞ› ogNmN‚,žLß«t—\Í)¨N–FÈ(KÁþƒÁ2]6sÝ>7“°ïqç¦(ˆ½‰í;0ZK´ Þ‰“çt fRÌ‹d¼Š÷ÿÐöɳâ5òô4¹‡(Ò‡eu¸úÌh×ØT*~*P =gæá°p#¸S\Ë©qF OÔ2žœö­HÑgø„'Ú&šý3%ã•‹Á]¯[„ßgu…ÔC–^Ô‹}?´¤œa®˜iÑj¬•ˆöì™32û—TIN¢­Ïf½s¥qås3çj¥‚šÔZ¾À[8-ðK]½54^noíM£üãx°6¬È‘îÀVQBßAà<)=ÖË“pqbÕ,{ÎŽLÜ…RªµÖ#¢3r›ð¶èô_ß‘‡ú5þ˜Æy¼OÕ®äìS¸ë¾ûPPIƒÿÚklC¥G—&lj1P+C!«XZÄî+M©h‰yEh:e»âø>õg}‚,Î>Y‡ËhÛ&`9Uót¬`-¼I„ P½-ñ¦¶ q²iøT§_Þã{¯ÞCiTÏ )»Ò5¥»|§©ŸŠHa±õ6×ÅØ[|1aö•*â*é+œiJŠÌH¢ÕFb §óíV+·H­üƒ0aBF]LV ë`ÑZEÃúå‹ÖÄ|þà $c‰@n£7]UÒçÅwëHH|ÖªÅ5ì³ÏÏ@Ç ŒÙðÂ0ñH¯¬Çf¯´#½Î„u±ˆ&‚ŸŸ¬.Uep"_ü¥ øp¼KïbSQ‰Hrë•oSc­nm!„O²]ðâdIï¼À4mú^eTŸ“„D™ xýîì΄i2>`”³ÔÆ$NèD=Ö\‡ô,hk¹ïë†é …PkjÝ•D‡:;·àÀ0h+džÑôGá· PšH«]|zàRæå‰WÊÞ·ì îXe†8ò‘ahžylÔÅ\k¹q¦E‹ÿ±×ÑCçY¹© öÝœƒcÙ:¿bé­ñH»i±œ¿¬}µþ ~ú±¨î\”»ƒaÏñR6l€ƒM5ú$±@éÅ|õGYûo¯%„BQcwæ†=y¦ž½qS‰4. {^7ô/Ê2è Úƒ-T+¶š¢„ƒé‘HãËÔÊ §•‚j-II€{Z•wÍY7'l^|rµŠÎGïÆúç‹&übóTjÞ–¨†ó„´xüº VÎæ¢"‰³‚\K<ŒÄmZó9çï2óˆx’ëîxôß}À‰›"ž>¤S&é\€Ó? ˆ^û§âsÔ•{ÒJ8Φ!$!R›^O‰íîk••pȶùköjþr}<¿dDy# ÝÙø¾%èËg¯YŠ–s‹Ê…k©.GB2jÒG‚P§€œ•v’1& Ðe±Ž\JÒÅDkdC\á#‚3½[½ ÊjóÐM0Ez¢V;‹Qàe`>ò[ŸŽ5lSöëHª|3"ºšg]¼‘ø6!䢺ÚTaÎsYüJB¸pïÅ,;Š‡!¿ïúÑ϶ÂhÓ-)Ø-FzÙÃi6¨¡Òöê?ò¤lŸÅÄzå%ŽTµxq¼l‹·ß¶áÐöÌ…"†¦Å±ÅóØuH`•íx“½ï9ƾ>Af)âK$’_‚¼¿÷Ÿ.F(‡ ,²—cÊ VFÀ/(cS $ï>*ì¦1å‹ZÔUµj¸s¡©ÙE>N³8=ÎÔîqB{%(Ÿ¦nXUG ]Vï»`©¿šAY3ü}>Ê‹÷rz4àþ C§6=:¶v[Ê_ÝÊk›N…™ ­7Ÿ Ý¿Fò™?)[Ãpüýò†ºR*ˆÇz‡­/¢¶ØP8Ì ðL¢¡ßðN×¥ÄB_²B|ñž ½°«Ž6é„ß[ô,9‘I3Vâ‡IÂÁÙKWæIФ¼$4BßP]Ù6ÀpÚ`=p‰Ü_cbýp?VK²~‚åà;6õÝ ÇvÑ ¿çcö‰Ø¥±AÞX—áÉÀV~þ­Q´ð—¯Y0ª ¬Çfй-¦Ô³,ò» ý–]¥+M’‹-ûñQoÖáfcP ;þœÁb%–\§7‹|Ì°"v`ƒn%Ós¬ëŒÝa)_;B´Ûtޱ澡ǻˆÄÊãO"ØMJô0ŸA]ÑW\‚øýÄ϶™À øölô‰vƒè–ÌPÛ¬ÕðfñÐNOãåÈí«pŽgEfå"Þ¨-ä.ݯ0¹¬V\M‹Y® †Í§ç_«½‡º$ÆÑ5a•È2ç[ÓÀcSYŸÃp”uR.š³ÇÚBëÇ(Ûeè¶Ilê…ËãdȧÉYÆÏûŒ†[Ò5ŸÕÄÓ}~êL¸;x”~ÑÐ`nõÌnY% ÷RÐ"M¿ä>R|ß‘y—Ùp¢¹ô¾ ¡•Lô+Âà3rpsU)!á`7ž Di¤QŽÿÜPÝäd4y ^òÄÀýWMÈG?ûn31Ù'&Bƒ$ ejy+u]â-Upé‘KÍ~©të¯V··N«Äµ‡Ãzüâ^áÁù3RühÝÒì˜.6ÿØwl¬Q]Ë¡#ã YX úÎÇCœÜ:á·ge}“–×Ã,Y¢=£ä@·ÆúsCk¬Ì†öù’ˆƒ<•Ym~xǵb·cLÏ7§’Mþ%/ø dÙ'a—|…'ž°uCVb1ANn KÂa3Š$åV™™K«h*SÍVÉÌ7|EØ®#\ñ¨æ-TÕ»7n݇cßîï·™ÔSêIPë2úâzÀrÕ§¶s6YûäÆ—£yŽ 24׊ãxꫦ¸ùÏ©™ ר·jM¯§8rtl.âÞ&JM—èa¬@$úgQ¬À®gZEØõÅçº`îÅôÅ2žªåò–„Tu€Ó ƒž<µ ™ÛVËQ[­Jò†oÞZÊѱݨÄ(˜n…N9¨Q ¾"Bÿ½6cö¼ßa¡M _¦ÆœŒt*éÓÔfµJ5ú¢Y¨‹£¾¨w¶“í^ðZLJÂ.h¦$Åý\ëºÕ©ÿ|z}M©JœõǨåþu‰èÈ;—ÿCSë'y¿7çÕÃØ×hÆïòÅÁ¦£¹M†PmË"’ÍÃ/ÑFIþ´HîE{«… ¾ø1Ì¡¾Þýú»-¹¦ªÚväéÎ.ÕFŠE{{8ê‚2É`ŸáÄ9Pãù´Eµ3±g·b­ï7‰,>Uv±”ŠÅõÓ Û÷[¸Ï蟒u ¨±ß6ÐÞyÕÇë[yˆ‹£Þ„ìãìä!®&ÿì²*Ì¢Ç,K\Cv^@ŠªTpg뛶äf_žŸ™0xB lÒ¹6ÿ¸P Ù¿jA~û’ˆ ] ë>DÄ£rñÃó„]áIh\À„²%Ò*Hv÷fn u¶éGTc=7YŸå‘zÎ<&ìGCÁ %©¿Í©:R$Þú\i¬s‚,îdOŸDñ™-îâ9›¥ib¿¹y‰Feè mæg¹"¦°UU{Õˆ‚ü(–É ( >"VÖåš;åÚoBŒ¶Lÿ¤$Üs»æ38ÊG~®Ý°©~«Ùs|áüØÂÌ?Ñ»I0µ××Âÿ“¼¡P<¿ˆ0êÑë›8'‚gôõ´‰ -:÷lÕ˜·4Œ,”'U Þ±ÍÙEÁ½fG@ÉöÏúŒ qå¡Q³ô“ŒÆší%Öv¸3µ€Øž†å‰u Y(øçõJQ=$ À|aÖAH•‚iN¾ÌÔ’¢6íUÆ!Ë7kŒQÓz…ßÊdh#Qs)Æw‰È’þsÂ0ƒžä˜ÜnÒ™cd ðôËâ\Ù‚a»Þ%Ä–©Å™ÑxÓUn÷ñrÜŸ.•š66M†º%¿^­0&ä¬X ƒ ;D –òK5Ve©7w~÷½ÓŽtè{ü˜_ö¨?/CEõ5·›ë]0mM€QB™…d‡úÓåþ§£‹<´Ï”‚ÏZó”­T0u2´nòJ.Ȭޥú#"ð¤$Ê!臡”.(­•!©ÞYE>öáä¨Q[?žOkÏ0=±"~†ƒ”ƒc5¯±„…ö‡/_iT ;\úêºâçCÿùýäà‰jBÙöÄÅð¤ÚzÛoÊJ·Ñe—aĸË?ï`Éá[Š‰á²}1~#¦³{H¸SBj5Påmz›ÖmÿXÞ‘òJ?7¶Ål÷éô³¦!>no²è†¦¿ 'ýla‘2ulq}™ÑFx~ŒüÎTÞ÷§`mÇ^éE’–=”úäî<½/ïÅOÝ3Œfª…¯3#åB÷7| æÂ-Ñ Jß–xü>É%÷pžù-ãR}â.¡kª”7ȼ¾•jy2«Á… Ü‘f:SËbº(žÇG虵%€ÂnHaŒÕi- ¥ÐuAzkx“µflF›]ÃŽ½¿NêÉã¦4Öà ²þòD¯4[˜S%×t¸j”›à’Ù@W~(I`ùV¶ýÕÔ•á>p˜«I¸Æzã²:&O³}[³S–üT¦nÅtSƒ«h{þb‰„%eå¡" ÝD‡ÌŒT’œö¹Êå•’$ãÌ,!ð(TÏ[Ÿ & PБsO©·-¸Ã|‚‘bñí¨@á³ïÇkÕF.‡ê4öõ®n©Ô ¢i—‹O¥œ¿5„v°0²Æ[u¿ô‡M¥ÕFܾîU®Gy&…sstuDØÚ2‰®/¥}uMâ*M0¢‘!""£úÌL…—¹›þv Œ ‘šULd_›Wšÿ4™*‚ï‰Ä:šå†¢>oÙÝ•¦^Yµ¸5èû–xD6RÒǸ €qG š¼‰{ñ'?’fiNŠ½ÙC‚J{NÅV_†®uô¬æ³„‚Ê–<¯¥%m´PîårW 1PýåiŒt\Bˆc¹0R þ€ÿôûÙž|¶<ÑJ }*³Û;S€ ˜œé ãsšŽL°G©¨¡¿áO}çÚzœ¼ß/–ÜÔã?+îû#w":õñ¹µÖåöâ; Ž¡÷äÍÜËwí“1X¸)²õœô÷¼¢(ºÜ¹Ô*ƒ~PyÝ™ÁÈÓ bÆæ©éë8êa8s‹}dYYð5>L¹E¤»`ÿÜ’³ÀgxÅóÿ1õß endstream endobj 277 0 obj << /Type /FontDescriptor /FontName /BQRQFZ+CMTT10 /Flags 4 /FontBBox [-4 -235 731 800] /Ascent 611 /CapHeight 611 /Descent -222 /ItalicAngle 0 /StemV 69 /XHeight 431 /CharSet (/A/B/C/D/E/F/G/H/I/K/L/M/N/O/P/R/S/T/U/V/W/X/Y/Z/a/asciitilde/asterisk/b/backslash/bar/braceleft/braceright/bracketleft/bracketright/c/colon/comma/d/e/equal/f/four/g/h/hyphen/i/j/k/l/m/n/o/one/p/parenleft/parenright/percent/period/plus/quotedbl/r/s/semicolon/slash/t/three/two/u/underscore/v/w/x/y/z/zero) /FontFile 276 0 R >> endobj 278 0 obj << /Length1 1188 /Length2 5735 /Length3 0 /Length 6450 /Filter /FlateDecode >> stream xÚ­“e\”]×öI© ¡›aè$ébhIéénéVZi¤¥¥$¤DJxæºîç¾ô½ž¯ïïürþ÷^ëXÇ^{m&:u-.iK„LáˆäsƒE2*ÚÚ`^ ˜›—‰IÆAÂŽ²$L¥Ý¬¼<@° (¿€(¿ .Páäå·¶AYeØþ J;À\àPˆ#P‚´9 4 {  ‡!½¸Òöö@Í¿2\š0W˜‹;Ì’ Z¡H Ìîˆ úË‘¢£(ôŸeK7§ÿn¹Ã\\Q¦€¬(“l@”EK„£½Ðf… RE jÁPNþ˜ú·¸¼›½½*Äá/ù¿»ôö!p{¯ÿ@88¹!a.@„%ÌÅñß¡z°ÿ˜SYÂÝþ½«ˆ„ØáҎÖö0 Ï–à®òpO˜¥: µ"]Ü`/Ã-ÿíÕ·¿€žÉÊÈ>ãøß ý{SwDj{9ý£úWôß þͨö¸À=F<Ü<<`T êûïŸÉ¿ŠÉ9B–pGÔD!../\Ôh HèÂ-až@˜'Ê0ˆÛD¥Q=ñZ!\pÿºOAA”Ë¿–þCÂ@ìo‚äþ!! Hþ7 ç¿ ¥¢ü›Pyjÿ0*Oý7ñAZ¿‰ÒþM(Ýß$éýC¨áA~ʧÅoBÕƒþC`TAË?åö¢ Xÿ(6 ÿQuì#¥ìø¢” /äô¢”]þ@”²ëˆ:+ò@ #=þÔB×íDÐã7¢?ÈóDöþÿï>{†ðôá¹xùø¼ü¨Kðý n..0Gäß/5Ëÿe+8jða0Ow~ ¶Mi -õ“Ë/ÃfGfݯú®{ªïÕÜktû¢JÎìËuúWåé$¶°·h=n¨\#Û_jŒÈtŽO¾Ýr7ßJ÷n¡Ò?IWñÚt¢ÿùj ­ñóÙ¾ºÚäò§Ò$ƒ‚¾¬£þ½\uVYííû_èÐ޹׿ÏÒ—O·× ©cæ£Ó$Lu. ç[ò LJÀZ{ågö ™cñÑîF|•ÿ 'ñÖ ÓrD×ü–佈ËTÀy4Hmtcu¤˜¸äzÔ‰[ûT«¶ÕëÖ ©fÍAÖm·ÁD#öÉ ãꑹôõ´þs-§™ÄR¦tæ´VÇ”1)£ØH¥gP™5¹Àf<ëçÕ$Ê¡ )Æ­‘Õo阑¼æ91Óµ‹Zú ürïe¶±˜Vœ„éRy—•KR×Ó˜Œ_”zkM®Üzß =ä«¿Wšï9f¢ ;¹÷›Ÿy&€¸wËxíR9yûëô­ÃhfßÅ’¢ó—u£c„ÀÅ^ߪq*Œ·úrÙz~ºá6+BC/ÝÉ’ŽÁ¶—’|w~x Z&Qü·>£$v÷“½;Æœ¨|êJ {ŽqÀÄaí/õò]²çpÈÒ H®O³5ÙOZŸÌt±ß»ÁÞ;õn/@þË’ÐhåøÔ¯ù»q¾~yE¾¸ŸáÇ™.“¾¨•ž1œVva6j¹‚÷fǯëûÏ âíeB~Lét® ->Öyî.ÚwT;L×^tÎeD¸C-ÕhŽ†d›ÌêxŽÝ6’úAË¢M¸h(Üž´DœuáË IÈ7†l,Ó8A§QÌÅìm¿qkLØ›¡ÓÚ™NQ⯡›y²WZž“1ÇŽ 3` ØÀkÄ~NÌe?üEù>a%ÉPæaÖ1Åéì–ÄpªÎ]öLúH‰!wÞ_y)ž¹‰õ`ù‹«pžÓjqþ<'V¡h+‰g"¬–|Rë;ÂU¢·|ųœ}„‚X³ âæܧörwv£hä)2ž“Óma%b›ÇÔŒHÉi¶Å÷e VäÞž½g£Ì•¸!žê(ä¥HUMI¶¡”göת„¶MÕS’-²øSø!å )ãß_”óWq}yšîÕ\Ðtï¹áš¯<Ñ&Yqú`tè 2žâ•˜mâƒ~s¯•Påœö0I‚÷\ "ûbß¹Dml5U«% "áxF—$èW¦P[fù©óÝÂO‹¼<5 @÷OêÜ×2ìpÇ©Sïlª¶3b¾9†8<éæMá±ñƦ /fÅãou1 ŠôNÁ©ÝIÇ¡4ßêϾE$2«êz+§t•µ°cJ+ì3<Ïá ;XÌJ¹‹gvxÝ£õ³¶MBêy£sj§ç:¶‰DòiÅ.þZö”Ñã™3û\ÙtB”l7®¶èDd’— —¯N@”Õ¦ æ=hü>îï¦/ê+“ô¯Ÿ¿:ÒnŸÂ¯Oä-Òhƒ33ÏBᎫóy«¤¶è¹æø^²ÐñÙ[*/扛¥|êÐŽ;Ð\G7+Uxüù'G“kl;øB¯5Å„ðhüOtÜDÓÖÙä|g‹Õ”²«ˆÜs½u°"K8¿¬#Å»²U}‡ã›É*œlýÝ ò=tÉÈšO„|rO˜3gkk°HëÛÐ^ˆ±™2¾Ü´U¤ef)FŸpG³ÉtœÉ<ÆŒd ÕW<ü¥M2ñë‹ H‹½žaÇÈ›éœÓp­èth ì¬aeiÉ û¡U:n};ýäýé¢OzÔœÙ"dÁgCk4ºyõNÌâÐnà,j½à®ØeQS?wi½ã3W·Ð7kÝ JwÁ ÂûÆع³ê‡…qö؆óëÊÏâ*ÝŠ_kè|ôX>:Pw¤w™|ü[ïv?p®wß¹f¢ÐÊcé)‡Ö´M—HôùÕX#£@”pEgaä€B«ØÑaï¥J-ÓtwÁ5ÕåiÛÌ«zsì‡=€ý’žÂËL÷´C¶ãÈn¢!T#—Dü©‡!­êyEé0uM:?^QîèÙ“*5ø<‰.èƒ[MV,$v-îæMÌ^'#ŽýÆÏÒ õ…@…vˆ*ßÒ¤W–ƒ E°~eE)Kü1uJç·;Չƚ!ÑD¢ï5ù\ªˆºqÇ=nœ¶ñÏIë i]•ÄUÙaé+lÇs–KæL‡šž’&ÛRŸU ‡àö.QÂ0ù>ìØø b‘‹)ÓsvóhH{p9b|’3 –¬vXݘ‚Ø6¦8”d¤¾’X·=YîŸÑ䋹ýèR¾$ÑŸ˜HZ¢¥ñ»…¬Gû\d¯ÆÄ~õԊܤLÊc;/jF7Åýqq°1¢MÝnzëØ‘#q Ìw™«õĈȩ,ĨaÌiSaªSs`èx½J£u3z©xOhâ¶Ïß)àèuþRGߧ Å’èo™¸šƒTüÆûIhSšÍ/­«û]Èëª?ìÏ/«9@w$LJY÷ÇÃFUUUó†ºCˆ¼EGìí¬æã4NkùÚç¥4™ü ž)—úl-–\\‡³jx¹„·/u!ÃKì+5¡kåæ. .Æ“„@¯lZ 8ÙôF¹Ÿ¦°Qå Íw%É»éZœpJa•À…»ÓK=Á÷‚ׇ‘ªÖóÔ|C{ºvêæ›"ë2TëëÒç—ûû".¯Ž:‚n0–‹“Ô±æZ sByÈ3æŒX3ꘖ)'Š«oXé’nÂ)òwõ£ æ»L¯™©(ï×ò›ÄÖJ;) ÞyŸß÷o¯2Oé Y/F0;‡†Oãü5À8Æ_„M£ƒÞ„ªÐ<©3): ÏÁ 2ЗÕé JKÞ™KOøl¸©¶nNœvÞL!ÖÀ,%2-¡i5K’4HòZú~êÐÈ×>Wã—¢Àw¾;ƒÑæ|YÕ Ûp¼Ä–.±nÌ^¡}'¹¥2ž˜.^Eaù qi†õ¡lÂBúžnTî /Îç ¾'”R]GRpñÃq—wæÑq›wÁóz ¹ßÄv½˜5bѼ΀^ëåvÀ´ådð Ú èùCUzßòÆUŒE²ä£ §g­2 Lpêý¾,$žæýS³1öuÍéëÅÆÙ±:!q°£r–3ÜÂÇng>‰¸›õÖgi:øŽx3l•€l[ªÉ£:K.Û)µcçãU£g³ZlÖ.FòcU’*ãÔîæÌd¦ªÎ¨ŠzYìôQwT¨ ˆ¡•\kiÎîW66và1ÿ<®‚8ÏVÀ˜1‘uyIqÀG'À[,ßJýX+ú¾H»´©«€õ ÇäüGDÀ‹Ãúâæáéå0ŠfJ'¿f¾ícúþJ£½kU^¦kåµVÀö Á+\^ó1µ´†xâ¹ÃÔ“ýÌ'u¡û/z¤m;¨g²[έYˆV3+œ<õ“:’À…^©ÖöÈfÕdÙ½aYÉÉpØg6æàêÞ,1U™>ïe÷Çlß)þF)g²,EV)“á³î&Rï[B1î¢Wr­yeDåZ6¤ïÑYUe`]óÊ£¿Pu°Z}(Ï£a:ÿ4 ŸRð0¬½.’ʤq\çÎúít€°!7ÂÈÙßàè ËågŒ™1Ic4þS> Mé˜mV‰WóNÍ{ˆ@I¯n°º0žánÄ:pí]¶ê]©¶¬ÀënqÄg·¬¼CAì«÷P~Ñ%ôõw Êy=ãâk†Ý3dü!×.ÂüM¸ÊëðóU.¬Æñ–TJÈôqÑ”·íq–i>u0."Êô¦kYtÓ(…`ó« ·0Χ ÿ¦P=fóÙÛɇi@›Täh{dӌ炳Wr:ö¬d .w7¿»œ>-}…ƒç.-»FøÛm³ºO&å=OJ‚ÊOÚú´ˆñ.†^Áïüúœžín^MÇOÆJpÈ_šM\ÞÅG£µì%ðE‘giºôºõ;“3½‡j»X(Wê9Ö1öAµZ½ŸL˜ÎVx‚Ê×rV2A ¶×…¦žÇ5¼Â´ã±®`íhýÕ©EKý…S‡ª0ûM®}æÇÖö3–­ç ³ÛÎñbUPŽsãlZQX˜žÛ©Ö)½= Z©þ #(²Ë þ’Å-Ã|Kö zvî@F‡‘_[CÔÎèv Ÿ˜T}£ª|7FÞ9àP᳤޼ð–ó¾ŠÑp˜ç/1ì2²ÅÑ®qßáõ$ˆ½í²ÙûÈEûÄ)è¾Á±D?mM¥æÀÝ¡ˆDPÓh m%1´x\Æz¼hsÛ;éÅ©ÐPC0ÒÖ6­Óx!}´.7¬/¹O$ E£urÈîÑœ<*}q Q@ëfšÓ[Û;@”’Ô \»ñXPEfÎæó2Ü7™˜¼ñ´=,IÂ<X…\×ÒM’ûÙõUKÔ¤ûÝ ²bYt†&{ýñðÚÅmèc¦j—>OÕ^n¶üðe1abL*uêæ]$ÑyïÈ:RnBí·D0¦ ù ¾‡ÄÒ"å¨øéÅ[îK8¹Ñ&]vÓ±TË((ºÁÇBÏJ¸Á¦Móaä h JgÄÛ¨ö¿–_6@áÚÝJnÅ7ËuÔ>‘3bxÕ•ä*Åk®'Ô•†zÇÉ{ʃ‹<ê:»oßy-‚;ðL/®¾€¾pOxÚ»÷Õ ÆÐ"wPøa*)eó›e†¦ú WÖ{bÀRј«JDzu¬´‰E.²*‡ÕüšOl'ž;uTÞݾïøª¾¥«Š#ëj5¸HkЕe¶´ç±Ð MëÉßqu¡ÜÛ%à tË3‹!eæ b ¹WÆO ëÝ-(=fÐUÇ›ç+î<`¸vê˜"5ÒÝŠæj&²¹zö¢¹ÝÞµ‰ýÜ3¶ú¹AóP«[æ`¦ çv7ð¡À“—•Ñ̆¦ ^îj.ê0º¾½ ‚á«NÉ"(y;ÎröqQŒÉÓólÆ>ûXß,qtíIÖF>BFÞêŒí±œtÎ «’<}³MªÕÄWìÑðm‹¶;íòhwò"UæIóÀ@A—Rfrª¿š‰º›O}ؘ¢µ`9Ÿ„Šï;•ª¢y¾èlÂL÷׸c¶QߧöÇ&~S²=BŠ_ýü-!ok¯ŸQ|}µ4 ±‰¡EéZ'ÉÔ'AÙvE)ƒˆîo ’û_´Æ {±B]¼õXļ4dù¥& endstream endobj 279 0 obj << /Type /FontDescriptor /FontName /BCZCDB+CMTT12 /Flags 4 /FontBBox [-1 -234 524 695] /Ascent 611 /CapHeight 611 /Descent -222 /ItalicAngle 0 /StemV 65 /XHeight 431 /CharSet (/B/D/E/F/G/L/O/P/S/T/V/W/a/b/c/d/e/g/h/i/l/n/o/p/r/s/t/two/u/w/x/z) /FontFile 278 0 R >> endobj 280 0 obj << /Length1 1477 /Length2 8348 /Length3 0 /Length 9191 /Filter /FlateDecode >> stream xÚ­”e\ÔßÖöééFŽº»¥KJz††¡APIiéî–ndîî¤;E@à™ÿ9÷}ð9ÏÛç3oæ»öÚëºÖÚ¿½é4u8¥ÁPKˆÔÙƒ“›‹[ «¦«+àæa12ʺA,<ì Îr·°07@ÚÓÀp ˆð ˆ€ø±²P7;[‹,ë?I‚i'ˆ›•…3@ÍÂÃâ¯aeáÐZÙA<|¸ÒŽŽív¸´!î7/˜ ‹›¶³òXBl윱€ÿRv¶†ÿ{ºüï’ÄÍn À7É €[C}`ˆ5P ׂÀüÿ0õßÅ<Õ-œþ)ÿÏþŸe ';GŸÿI€:¹xz@ÜjP0ÄÍù¿Sõ!ÿö¦Ûy:ý÷ª²‡…£•´³#úwÈÎ]ÁÎÖ´ó°²x¸yBþ†8ƒÿÛ|lÿrTQU5Ò–cÿ÷qþkMÓÂÎÙC×Çå?EÿIþs?1|8nvÞcÄ O„ÿþ÷ŸÉiÉ;[AÁvÎðï_`áæfáƒÿ0àÄðåØ9ƒ!Þˆ7Ü/Ëê߀Ä` uÃúç4ø@éBÿ&Pæ‰@Ù'åžH”ÿ ‚@…'⟈Tz"^Pù‰àê*OWW}"¸ºÚÁÕÕŸ®®ñ‚«k>\Oû‰àz:OÄê>\ïÕÁ þCÂðšFO÷bñDðLË'‚{±úqƒàÁ!|¿nÎú/„»³ùòÁ§aëãb qþ+³û áFþB¸Ç¿nÅé ¹áVþ*¿Û@è_·âò¤ Ïu±pƒ8;B¬=ž¢Üÿý÷-þO>8ø=†þÕ(7¼׿>i·¿Þ†û_/ðTŽ®íñæokð.=Ÿ ßë ÿŽÝÜ­ nÍ’Þ¼×_oþÍŸG ÷_ïÄç_øÿ^U¨·/'?€“‡—À?aaÿÿ+ÍÊÓ >½ðëþ¿lm oˆÖÂ,ÔJôƒ}Rç’wòy㥨lˆ261êµ°©vìàùXDÇÂAW¶ÕƒÛ²T"¼mÔmÚ7¨ÜÃÛü´FNÞ»Æ$ÏxÖÚ0}yȨ1¹:T’`˜ß“qÚ{£É"§»ƒ¾L‡ÐiìU×™öA@Ð@!ÕQ/äc /6~²kI(_ÈÊü„8”•±àwö!MìKgÐ6OÂÛ<Œìø3ÄnhðÊÏÉ€‘_=£_ŽyÉÚcãhAÂ+üy!3c ½{Ë:½/dYþ”;Içläi’EwÈ'ȸS3“ú/~úcW ä¢û¦ÛncÃ#¾ª‘`-ŠÉ_üQ&"­–"4Ú€"c`û7ÐéJ–M½M«™# 1¬á6óC«K"·…xágµë†SÃœx”K,1þÀQQ­¹ ™dé„é3ï@2@°aÇâQ¶W2îUýÞ%½/‘7={éô ÇÎSò8z<ÂtRÇLùÖ,Ä#?Ê™ùº9öë¬v_÷cÎ\ÌÅ–b‡^p»W§¾ÂPÃg ÌÓö¼¤ºGU[N¾Ìy¼ŠSOP6¿ãvØ:6¿©>'˜V‚ü =CD™fG'ùóÅuØ|Œ¡Ñ|¨)Ø'ãÍÆAT©*~( Ö#rö®§Ö­ä UÇ ðÎŲî-›’’fúäu¤Ãaü‹Ü!Q)à0í¨vG¿50\x欎:ig”oÝþ{øó„·ûþªZñ)g%J·þK6ø6/40¿g}Y1·b¸4n/®îÖÞ•\\H÷ðÓî‡(ï@Ìþ¢/6ðÕ^–…ˆÖT;Ôˆ3~ãxÏÒ=Ô W×Æ™_ìßéXyŠ%ECgÁ9ê&P‘¸x%á}Oà,¿EºFÙÙº¼<~{†ƒN8ŸèŽR%j]@¬» UÁQµÕÒ.Ú«Œþ†;©.E¡6Šå\¬KÎìºh•è¯0aT'½ k\’¼OÛ“ôúìËjýù·ž„*õ§»IѳȔ1›^‘C¿ØLçû1f¼ˆŠVJÞí°2ââ;§Ä f´¨ñV·SÁAi¢|þ•,©JAq`X}ÏuŠ ÞgyèóJ¹*½MÇëÃÞ˜Á”Nù·d"¾RŒq(ë€ò]ƒœÉw"‹œRz©!Và]úzéÌ'ÜçÒãIÇ3 #N$ð8¾_?=ñU¬5½þ"×ÎåXãZ5Å"ËvƒÅíçyP¤DR E[udžõìð—ïyƒy\£Z¥ù;>GÅó~ÇÖ„øë¦Ûî€1i3¹ÐÏÇÖeÃDUæ»êÞ…ŸGCŠS…—8¨ƒ:‘#Høx©Uü@–Q礰ÒfŽQò~y Üôw½¨íÈ\ á f±v b£¢Œû- â$BIÝmã„ ”SßÉ&IB+.þÄ¿h¿r*·<¾\_KnB|˜UŽ;®xhþà-NwÔÛt”åO£ZË÷"²k¤ÑËoØ€¡Vôô¹3†ÆÁžg@/žéÊYƒvH‡mÈpr ªlßEŸˆ>¶¬b^îë¦ôyï°ðž%ÊÎýQ'ðUðkæ¶çÎjA°ô­¾‰û3%YM©ƒJÞʽŽÐ=D| 6ã£VþÜ©¢”_a6O(d¹Ž»ÛŽf@ßD…³}ŽjäÒ?³é;«E&?ʃ÷q„–þ¿|;õ˜Ö²]Œ£–û›|‘ÉócªNx5<ܼ¹e©N¹QAÖvJìú,‚ 1lrÕm9hˆ¥m$À´üž¡Ë«l3ôáÏ^"nWZð"Fz%T5²ØëˆíõNÑ«îͪEÄÉ qC²w±9Á>D2gײK+_)~“3¸úö¿©ÿF-¡º…¶ÿ¢êXYDµãš9YÀ]ˆ{×>{4׿Ké¬Obé.“#}ž+>^QPKô‹h}–2Y’¥¦«ƒ‡•iã'öä¡VUdí½¡ËyÀ[6où`1ð•©ÁÌe%¶=§*»’EŸøDê·°1õ,?âÇ@ õí‘|D†˜x5Çóó:Ds¾e|üM-„„Ü1=6&˜]âôºc¤Ùo”ž˜röa­ÏËc•Ó°¯ŽÓïýv²bä´¯BÏóŽù¼8lQbNÇ^Žà·ôxÎbé¥þ¹ò-áDÿ î׋®é$1'-–[+¤,6³H]Hh, IÊàö'r† lèÀ+qŒà,sË«ˆ„¯Òú¢E˜+ì™”`žÖø¦nâèv“mžd]Œ á?ô–U»>&0Ê*¹&ØS f«µ@â´æ-'Ðkh–ß¾šz7›àe‰D«Lú¹‡ßø5°ðíL’šDeVÝT@5HOm*™AßÁ8 ªþŒ]»t-mƒbí†l+ÉÒps…!€5„¸¸}ŒIàrÓEL©Ã1i8Fë­)©~”µÌ>9€åöÕü›âìè«€EíåO¥ÔuEœ ßÒmÄ“^ÉÃC”ûhØþ'_]›$5mZ³¹Ù¯uœµFËŸX­—*4¿ù½¶5Õ?dª›ÅC¿ÿi#{Ó›˜í¸ÝdÔ°Ó­³/'u¯:À'õÁÌR–1ë1ˆZ\"j‹ôWjXn›ZÝI~Q°±hµäN½¯l²Áåå÷^.½PªÅðcî–hRì‹ì%L¤‘°A±QVrïiJ°!Þg…¨0eÈóò¼âBüúÒóÊ`5=*ôãç§W?9ù-ÑÞR´ Q³‰­,Kds#ÉD~Dõ)©\kIm^ÔV¦¾}Ì–99ÎPV›{UEºjDˆ®ð<Þ±?ã`2EûþÝIÝðüŠµÔøkLFn£ Zo ÙõRñˆÇ£–)§^Ÿ>˜7­6ý™Ôn?f‹7’®™ä-Ñ®E³|÷b):¡FPÿŽ&Æ;˜á žé?ĩλXï]²QÚGïÑøN@×]õ±wºÑ¡çDüâ:8JNaU7:ƒå­4Ô•¨TŸ ?.Ýr¹üÚ”–DŠ&¥µL:^$¿¶î»ìT[O6¤Ø 1ÓÌÐ6{&)lãT/4aä ðrUë|+ÃJjWß"Šà¹Œ¸8uøú:BHa|ê½Ôã~J)­³ ûÇ´âô°¶\Åí40 yÀ¦@Ƨ(±“¨u›²cµmE‘pS)Þç4R‡¿&£ú²RM¹º\ê­ââÖç\’Š“ÔíÕÚo‘J4µÃ'W$GÃÌÅj¿Œ*-ÅœgTMK:mšÂ,ª'òH]ùg‹#wf€ÏíõÄ!A‘×£‘ï²ùºšÞD¤ìD=[„by•é&ÅæË/îj¤nÞ¼/¼[å®7jPQñöÓõ%‰NŒ¥7Tõ¡`ü’Îf|ç7"š³çG]RIsµ|îØ‚Äü)£¦Î-Œ/Ÿ¥&gòèY}/I^N}½˜9A/˜Ó¢ Žuî¶b––® äL‹\¯—4ӖЩgŠÍÓ#¢•Z13ÅIÑcç”9Γ&X<OF…Kêé¦$Ï‚l¸nª îÈCˆÆþ ƒ¡XDg2!nÓêj.–§”󨹣e…ê¸ÄeV¢¦así—û‘®nl«›Òêþ¼U˜/sO뤳k ™_‹FQGä0ƒ†Òî¤õ¤Ÿ‡±Ñö¢TdØ ß¯¢xKù$ùØ:ÙÒ‰ú;7vd÷\¤7 Yªìæ¤0Íðx8h 3<[îj鯊 ­ÁXå¸4~ËâÀÉ219ú¥Ïž²ZµÐÁ”"*?_ínEÞ£öºr¿Oï÷:$¦3j0a·¯‹ëÇŽ§Iõž ÿ\qø\w¢áMåwŠ2‘aà VÛú(f°Âï ÍS£AÒ’}»kÊ#Ô¨…§gQ°üΫ¸K8…”Žll­‹Gêj„Œ0½iúâ‘á@(¨%~«¸)oÖ®ÇLs¥9~.¤Eµº`úLø·4M!ÏÞɉg†s üй½îgÒоŸ5ÆBߎª6V'ôfÄÚˬœ ¼·ox:õ&‹h…3C±6'9Eƒù:t4ùÊ1Lêí‹­CM¹ _ZÝT)c·Í£x½Ýç¥þ}=‹F?÷cƒáO—µÉÊ”¼¥®«@‘>½NI¿›%ižÓí+—Öæ´—‚TÇ/Wιy§´ˆWk_MŸ¦—æù…ûªgà@3å~wOj-«ïN»47¾÷Õ¼Qa‰ ½ë²h:zFQdq>ÚK¶²‹/ø¬qßWÙµÓ•ÃN†­\4]ÍžW>byó™±4ºÇ”6Ý­HÖз t&ZN¦œæ>a1˜3T]Äh±¨Ëi"@Þ„Û#¦y¸4+eˆ¿"4x^¹!PÂ%/tÿiv¯¨Û©óC·™}Tž“RóyAuØr/­Oë¬åÃU<¥á½¾ªû,ÉÒížO±Ö'i£ÛXªúÎ3#K®žÍHуΘ¢¸:”1Eî :É­d\ ®Þ,—ÉA+þ¨ÆÙÐÉ!§P¯‹˜é{–[åDŠß>z4vlÿ‰ôÛˈü©µ¥êÜ,C3Ææ7u.åuZùRó–šÇ£AßZ€NóÇAÇKÌÉ„½’ÍëÂIZD*ñÛçöŸÅØ5Ñ6%죟œtU!¿oóŒ–ZDŽvœ¾iöŽ€òìo|_7T¹+‰šŒ³îî£k&‡âå˜óùcz'ˆ)•ôºÁ¿¢*Òƒ—4 ȼ“’:l¢ì1•Q™'ß-Íß—$*v¨­¼#¨ÞxmÝÆ_ƒ¾)L¡âc†ØòšBô=p€øñõåýþ÷Ü+]½ªýyÍCÐ:Ùno‡9La üg'èI ‡t°{ƒ>‰Ë¿¼¤O€õÐsÄN•žóøÄzjC¡oiXNÇ.'Úûhi…q?J„©*L¸zÄ;…Ï‚±¨ðP÷qÖ¤–Ëã+³Äò­6íZL >ê•,K‹ÂQçÉå–^\4߈ߤËò­fÇƯNoU‘Ð+sõ>Œt—~‹é ̉ $x d—(¥}—€Åˆ³%(P%(¦àkWZÛ=…iCcB!°1bK9%éý®ø‹Ë _ã!BŸzÕ… `U«ª"( ý¥‡»ª-Õ$ßRÈAûrsSâ*Ñš7ŠL”ö™÷xá…#óŒ ØúbæâsXY533U¨ìQ­vhÍ„’dg ÆR÷ ÿ®,P¿|Þ7ÔÝòb•–zh†vƒc·Tè íìB ™Pöqó',Åá<|ÖßÝ¿2.¾©Ó°œÈ”͹•nÛrø'Þ£k®K"HàS°`œ2ï˜Ú½yFR,"Lx~ “4èÞ‚öwȸí»#ñÉO§øâeÄ›e-ÊŽˆW„ÿ$<Ô<S0®hO+Šœx¦êçg0MZÐÔ }]Ó,Ì„†Y̓Îþ]uNoÑ J©ð³×”c,KDG…+ôlmªüm”Dq…ºœà‡¤ô»ûìË—ë¸Æ¥ZDHŽäŸbT€‹m<[·»yg ö¹f²¥Ëïžßx=ÜnîA<ÁU²¿9•ç 6õ?|…†sÜÅeŽml®{e‚¼ˆE™-î9C]öW‚ê†Ñ"GÆüïí`1i˜o÷È‹Î!kSÙzW«;ÀêbÆÂñGö2ÜjæíÛÊýŒb¨½¦Oñ¢–˯àà Ôädw‹WÉQf_ˆûx5…— oÊšêT>µ5Ê`®ñäz½¼#Vó+éµövèQL<f復1w­å*@š%ÚOH@0V±uÙ}¼&Oó Ù •#Íj·Ïuì˜øtþ’:ØŠG“~ŽétÂD:2Îìèuµ²êy1ñ‰œˆFOŠ,,.`¬Z´[w©à†›uåíq]š¯ŠÌeÝoT øæšÅUÆ⟌”âo:¥ä0šBñ+íµSLŒ) !åTñýêí+H±OHV±hÇÉ ïAÓ8n©uó´â®±æÍN«æq"ËÜáÿR®!–Ü^œTbªöö¢E¬~n™þM~7W†q]>¥ ûuï…Âù*6ôûPºk ªâØ¥³¼}Ѹt·‘ßæ4•MQ&ÕÏE¸˜&)”!,Z´'ï.©Ür4”nÍ-«2†:Χ¥TE ÑØ\H9zxØê/ G’éŒè‡a( +Qü®H‡¢>WLOgã\z1NËÙj&žzÐpØ–«Î_ø]ª²ùÏÌmè¼3ÎÍýŸ³I70I†_dû¶¹=“ÓI(ª†¦HY1ïßSíøÂÓ9øè,•hY¤¤Ù¬Ë€Ê´]Dº¤+½×èï8ÿkw“û¶hõŠ6ƒ! ¡ä9¿©Gi¦Õ]âÇ€HèuþÉ—b$ytÿ›œL+ÔÞgL0.µô±“ÒSA¤à-,¥›áp¥u¹u·ä/§Îc0Ù¨£î‚Í I—Øσ¥]ä ÷OÄÝ_¿¦äz:ŒIÝpÓŸ¾dDÞ£@ÆaCˆÉÊœæ1QgLŽqYzË—¨ÎÔm}øˆƒôÀ ;˜„ícHyj´ÑËé Öimܼ÷zç”X)«¾vVvtaHkÑ ÄBx"?-#§®¶E™¦€›„æ·Áä•ÎL-=¨ëB³•¶Ýån–‹ø l˜RuWT.Ì£b²£Û¦»9¶d¹ñ‘Þ+[¶xLŸqa#Dn0nÒû§¼à±0Ìk#(²c®|¬5õSæ=¤‰þæ¾Rœ|t´dþ™s&ä’èfgÀM‘öÑ,ŽèÁEýúñeÇÙXOÏ$vaäåån¥òÒ©¤ mÖšÃV¹÷«Ï9¹³§#9x‹ð-•áî }Ç%Ú?©ÂBÈ”üŒ®Io…Ð6LmW †!‰ |P?˜I¨áb ¤øÞ+1⃉DUÓÇ ¶®*®ët é½12ãc/­üèg:=Ò$–ÁA’# n‹ñ­Yø;œ£¯k­s4ÄVü:#|õ“ÞÒy9P`Ô†ŽçÅ eÏa•N›Ð)Ô“\ö¹ÚeM¬â'b(hËŸ†£¶ ¢û¤OoÞïÆb©ØJDƒ ¢fĹH K&-ªnnl0KÔ@9‚?ºýw$nƒÕç;oCñî¯BòÌ8ÚS#Å¿°Y„Ö(2‰Œ!>N(4á)ÆF|8™*D·Lð¼Ë ø!%Í(^káÙ Éé:ÄÊ•Øúí–®ã‘;?[ß– aì: :>Þp ôÀÁž B%ó)A͆)$ ÜþžI C®§§ÜÚ¿Œ"ÞÒ%|8ÁÃhyÖ¼žßÐ$0Õ:¨YDDýí]°k¹ð{¤Qé¼[ÖmNÓa.õÊ·µ¼z#Ã6fÑzÂdÙ¦ärÛoøAZ@oo áå3»–äÆŒ­Tz0‰å×Ëô ÛíFqúíÏ¿ 9rõ ÎÓQ‰»È€vιýW š*1ybZQ{ï~ê߇ËçDªîš{Xz«µïÓKrc˜TV† ?×EqÛÃÈÞo1ßG ‡¶ ¦E_ßâæj¸ÿØ©ä)§EL¾J÷Ú ?ˆ¼8¤2bkF\gV®ØœPª×äçç\£ð‚”°lø­,= ž'ཨì©®ÅóìÚÂ}ár•(µAw³÷ÂÌ.oßÖ8Iå“c˜Ëi¶·‘hÀõ´“€õFê‘Ü7>¢»¤MIŸmb[+WoǺÍûZb›xcëD׬3ÏøÓ_/‚à Ye/’È{ªÕ&œ}­´ë«OXÅcí?w³ 5-uG¶woë¯,]4À”ð¦Ã§4þ¸ªÈ×"(å«ý~é“[ËHüj,ø¬y$)€ÍÏë—ï‰T£®Šnëùõ{Ü ›” »æ‡õ)Ã@mÌÎÑs£VÆŠ>3ò‡3ÝQ[Sìj+ômuë€1âH[yçbý›s¯³íFžBIÁóçEBý†lÙœñÂmñÉP¨S(¾bApÖ §D—9º¨ÃèyBFþa2§ÕoäY®×´¸wÚpB¹Gù\X¯©ÊO²Í]Çʺîƒ2‚ý52ãÛã9®`Ñ›d*&g¤èlávö$úõ$Þê†èÒcßÑ¡ò© x‰y× 3%¶æ!Æÿ?‚.œ endstream endobj 281 0 obj << /Type /FontDescriptor /FontName /KLLZRD+CMTT8 /Flags 4 /FontBBox [-5 -232 545 699] /Ascent 611 /CapHeight 611 /Descent -222 /ItalicAngle 0 /StemV 76 /XHeight 431 /CharSet (/A/B/C/D/E/F/G/H/I/K/L/M/N/O/P/R/S/T/V/X/Z/a/b/c/d/e/f/g/hyphen/i/k/l/m/n/o/p/parenleft/parenright/period/q/r/s/t/two/u/underscore/v/w/x/y) /FontFile 280 0 R >> endobj 101 0 obj << /Type /Font /Subtype /Type1 /BaseFont /ECWVAP+CMBX10 /FontDescriptor 253 0 R /FirstChar 12 /LastChar 120 /Widths 248 0 R >> endobj 99 0 obj << /Type /Font /Subtype /Type1 /BaseFont /SOWZCQ+CMBX12 /FontDescriptor 255 0 R /FirstChar 46 /LastChar 120 /Widths 249 0 R >> endobj 142 0 obj << /Type /Font /Subtype /Type1 /BaseFont /VIMHMC+CMMI10 /FontDescriptor 257 0 R /FirstChar 61 /LastChar 61 /Widths 239 0 R >> endobj 102 0 obj << /Type /Font /Subtype /Type1 /BaseFont /QKESDY+CMR10 /FontDescriptor 259 0 R /FirstChar 11 /LastChar 124 /Widths 247 0 R >> endobj 98 0 obj << /Type /Font /Subtype /Type1 /BaseFont /JWVXVG+CMR12 /FontDescriptor 261 0 R /FirstChar 44 /LastChar 122 /Widths 250 0 R >> endobj 97 0 obj << /Type /Font /Subtype /Type1 /BaseFont /OBFNYA+CMR17 /FontDescriptor 263 0 R /FirstChar 50 /LastChar 121 /Widths 251 0 R >> endobj 127 0 obj << /Type /Font /Subtype /Type1 /BaseFont /AFFQBO+CMR6 /FontDescriptor 265 0 R /FirstChar 49 /LastChar 65 /Widths 242 0 R >> endobj 116 0 obj << /Type /Font /Subtype /Type1 /BaseFont /UBDXIM+CMR7 /FontDescriptor 267 0 R /FirstChar 49 /LastChar 65 /Widths 244 0 R >> endobj 129 0 obj << /Type /Font /Subtype /Type1 /BaseFont /DTVSLC+CMR8 /FontDescriptor 269 0 R /FirstChar 12 /LastChar 121 /Widths 241 0 R >> endobj 115 0 obj << /Type /Font /Subtype /Type1 /BaseFont /KHAVLZ+CMSL10 /FontDescriptor 271 0 R /FirstChar 50 /LastChar 88 /Widths 245 0 R >> endobj 205 0 obj << /Type /Font /Subtype /Type1 /BaseFont /GFAWRG+CMSY10 /FontDescriptor 273 0 R /FirstChar 15 /LastChar 15 /Widths 237 0 R >> endobj 176 0 obj << /Type /Font /Subtype /Type1 /BaseFont /DIJEXQ+CMTI10 /FontDescriptor 275 0 R /FirstChar 97 /LastChar 116 /Widths 238 0 R >> endobj 103 0 obj << /Type /Font /Subtype /Type1 /BaseFont /BQRQFZ+CMTT10 /FontDescriptor 277 0 R /FirstChar 34 /LastChar 126 /Widths 246 0 R >> endobj 117 0 obj << /Type /Font /Subtype /Type1 /BaseFont /BCZCDB+CMTT12 /FontDescriptor 279 0 R /FirstChar 50 /LastChar 122 /Widths 243 0 R >> endobj 131 0 obj << /Type /Font /Subtype /Type1 /BaseFont /KLLZRD+CMTT8 /FontDescriptor 281 0 R /FirstChar 40 /LastChar 121 /Widths 240 0 R >> endobj 104 0 obj << /Type /Pages /Count 6 /Parent 282 0 R /Kids [74 0 R 112 0 R 124 0 R 135 0 R 139 0 R 146 0 R] >> endobj 160 0 obj << /Type /Pages /Count 6 /Parent 282 0 R /Kids [154 0 R 163 0 R 172 0 R 183 0 R 195 0 R 202 0 R] >> endobj 216 0 obj << /Type /Pages /Count 5 /Parent 282 0 R /Kids [212 0 R 221 0 R 226 0 R 230 0 R 234 0 R] >> endobj 282 0 obj << /Type /Pages /Count 17 /Kids [104 0 R 160 0 R 216 0 R] >> endobj 283 0 obj << /Type /Outlines /First 7 0 R /Last 71 0 R /Count 8 >> endobj 71 0 obj << /Title 72 0 R /A 69 0 R /Parent 283 0 R /Prev 67 0 R >> endobj 67 0 obj << /Title 68 0 R /A 65 0 R /Parent 283 0 R /Prev 63 0 R /Next 71 0 R >> endobj 63 0 obj << /Title 64 0 R /A 61 0 R /Parent 283 0 R /Prev 59 0 R /Next 67 0 R >> endobj 59 0 obj << /Title 60 0 R /A 57 0 R /Parent 283 0 R /Prev 55 0 R /Next 63 0 R >> endobj 55 0 obj << /Title 56 0 R /A 53 0 R /Parent 283 0 R /Prev 51 0 R /Next 59 0 R >> endobj 51 0 obj << /Title 52 0 R /A 49 0 R /Parent 283 0 R /Prev 11 0 R /Next 55 0 R >> endobj 47 0 obj << /Title 48 0 R /A 45 0 R /Parent 11 0 R /Prev 43 0 R >> endobj 43 0 obj << /Title 44 0 R /A 41 0 R /Parent 11 0 R /Prev 39 0 R /Next 47 0 R >> endobj 39 0 obj << /Title 40 0 R /A 37 0 R /Parent 11 0 R /Prev 35 0 R /Next 43 0 R >> endobj 35 0 obj << /Title 36 0 R /A 33 0 R /Parent 11 0 R /Prev 31 0 R /Next 39 0 R >> endobj 31 0 obj << /Title 32 0 R /A 29 0 R /Parent 11 0 R /Prev 27 0 R /Next 35 0 R >> endobj 27 0 obj << /Title 28 0 R /A 25 0 R /Parent 11 0 R /Prev 23 0 R /Next 31 0 R >> endobj 23 0 obj << /Title 24 0 R /A 21 0 R /Parent 11 0 R /Prev 19 0 R /Next 27 0 R >> endobj 19 0 obj << /Title 20 0 R /A 17 0 R /Parent 11 0 R /Prev 15 0 R /Next 23 0 R >> endobj 15 0 obj << /Title 16 0 R /A 13 0 R /Parent 11 0 R /Next 19 0 R >> endobj 11 0 obj << /Title 12 0 R /A 9 0 R /Parent 283 0 R /Prev 7 0 R /Next 51 0 R /First 15 0 R /Last 47 0 R /Count -9 >> endobj 7 0 obj << /Title 8 0 R /A 5 0 R /Parent 283 0 R /Next 11 0 R >> endobj 284 0 obj << /Names [(Doc-Start) 96 0 R (Hfootnote.1) 128 0 R (Hfootnote.2) 151 0 R (Hfootnote.3) 192 0 R (Hfootnote.4) 215 0 R (Item.1) 130 0 R] /Limits [(Doc-Start) (Item.1)] >> endobj 285 0 obj << /Names [(Item.2) 132 0 R (page.1) 95 0 R (page.10) 185 0 R (page.11) 197 0 R (page.12) 204 0 R (page.13) 214 0 R] /Limits [(Item.2) (page.13)] >> endobj 286 0 obj << /Names [(page.14) 223 0 R (page.15) 228 0 R (page.16) 232 0 R (page.17) 236 0 R (page.2) 114 0 R (page.3) 126 0 R] /Limits [(page.14) (page.3)] >> endobj 287 0 obj << /Names [(page.4) 137 0 R (page.5) 141 0 R (page.6) 148 0 R (page.7) 156 0 R (page.8) 165 0 R (page.9) 174 0 R] /Limits [(page.4) (page.9)] >> endobj 288 0 obj << /Names [(section*.1) 100 0 R (section.1) 6 0 R (section.2) 10 0 R (section.3) 50 0 R (section.4) 54 0 R (section.5) 58 0 R] /Limits [(section*.1) (section.5)] >> endobj 289 0 obj << /Names [(section.6) 62 0 R (section.7) 66 0 R (section.8) 70 0 R (subsection.2.1) 14 0 R (subsection.2.2) 18 0 R (subsection.2.3) 22 0 R] /Limits [(section.6) (subsection.2.3)] >> endobj 290 0 obj << /Names [(subsection.2.4) 26 0 R (subsection.2.5) 30 0 R (subsection.2.6) 34 0 R (subsection.2.7) 38 0 R (subsection.2.8) 42 0 R (subsection.2.9) 46 0 R] /Limits [(subsection.2.4) (subsection.2.9)] >> endobj 291 0 obj << /Names [(subsubsection.2.1.1) 118 0 R (subsubsection.2.1.2) 119 0 R (subsubsection.2.1.3) 143 0 R (subsubsection.2.2.1) 149 0 R (subsubsection.2.2.2) 150 0 R (subsubsection.2.2.3) 157 0 R] /Limits [(subsubsection.2.1.1) (subsubsection.2.2.3)] >> endobj 292 0 obj << /Names [(subsubsection.2.3.1) 158 0 R (subsubsection.2.3.2) 159 0 R (subsubsection.2.3.3) 166 0 R (subsubsection.2.4.1) 167 0 R (subsubsection.2.4.2) 168 0 R (subsubsection.2.4.3) 169 0 R] /Limits [(subsubsection.2.3.1) (subsubsection.2.4.3)] >> endobj 293 0 obj << /Names [(subsubsection.2.5.1) 170 0 R (subsubsection.2.5.2) 175 0 R (subsubsection.2.5.3) 177 0 R (subsubsection.2.6.1) 178 0 R (subsubsection.2.6.2) 179 0 R (subsubsection.2.6.3) 180 0 R] /Limits [(subsubsection.2.5.1) (subsubsection.2.6.3)] >> endobj 294 0 obj << /Names [(subsubsection.2.7.1) 186 0 R (subsubsection.2.7.2) 187 0 R (subsubsection.2.7.3) 188 0 R (subsubsection.2.8.1) 189 0 R (subsubsection.2.8.2) 190 0 R (subsubsection.2.8.3) 191 0 R] /Limits [(subsubsection.2.7.1) (subsubsection.2.8.3)] >> endobj 295 0 obj << /Names [(subsubsection.2.9.1) 198 0 R (subsubsection.2.9.2) 199 0 R (subsubsection.2.9.3) 200 0 R] /Limits [(subsubsection.2.9.1) (subsubsection.2.9.3)] >> endobj 296 0 obj << /Kids [284 0 R 285 0 R 286 0 R 287 0 R 288 0 R 289 0 R] /Limits [(Doc-Start) (subsection.2.3)] >> endobj 297 0 obj << /Kids [290 0 R 291 0 R 292 0 R 293 0 R 294 0 R 295 0 R] /Limits [(subsection.2.4) (subsubsection.2.9.3)] >> endobj 298 0 obj << /Kids [296 0 R 297 0 R] /Limits [(Doc-Start) (subsubsection.2.9.3)] >> endobj 299 0 obj << /Dests 298 0 R >> endobj 300 0 obj << /Type /Catalog /Pages 282 0 R /Outlines 283 0 R /Names 299 0 R /PageMode/UseOutlines /OpenAction 73 0 R >> endobj 301 0 obj << /Title (GL2PS: an OpenGL to PostScript printing library) /Author (Christophe Geuzaine) /Subject (Documentation) /Keywords (OpenGL, PostScript, PDF, SVG, Printing) /Author()/Title()/Subject()/Creator(LaTeX with hyperref package)/Producer(pdfTeX-1.40.3)/Keywords() /CreationDate (D:20091016211400+02'00') /ModDate (D:20091016211400+02'00') /Trapped /False /PTEX.Fullbanner (This is pdfTeX, Version 3.141592-1.40.3-2.2 (Web2C 7.5.6) kpathsea version 3.5.6) >> endobj xref 0 302 0000000001 65535 f 0000000002 00000 f 0000000003 00000 f 0000000004 00000 f 0000000000 00000 f 0000000015 00000 n 0000005939 00000 n 0000165319 00000 n 0000000060 00000 n 0000000090 00000 n 0000009638 00000 n 0000165196 00000 n 0000000135 00000 n 0000000159 00000 n 0000009699 00000 n 0000165122 00000 n 0000000210 00000 n 0000000260 00000 n 0000022056 00000 n 0000165035 00000 n 0000000311 00000 n 0000000356 00000 n 0000024675 00000 n 0000164948 00000 n 0000000407 00000 n 0000000441 00000 n 0000026528 00000 n 0000164861 00000 n 0000000492 00000 n 0000000523 00000 n 0000026775 00000 n 0000164774 00000 n 0000000574 00000 n 0000000621 00000 n 0000028993 00000 n 0000164687 00000 n 0000000672 00000 n 0000000724 00000 n 0000031124 00000 n 0000164600 00000 n 0000000775 00000 n 0000000808 00000 n 0000031371 00000 n 0000164513 00000 n 0000000859 00000 n 0000000917 00000 n 0000033846 00000 n 0000164439 00000 n 0000000968 00000 n 0000001022 00000 n 0000034092 00000 n 0000164351 00000 n 0000001068 00000 n 0000001094 00000 n 0000036220 00000 n 0000164263 00000 n 0000001140 00000 n 0000001174 00000 n 0000040105 00000 n 0000164175 00000 n 0000001220 00000 n 0000001250 00000 n 0000040166 00000 n 0000164087 00000 n 0000001296 00000 n 0000001327 00000 n 0000044100 00000 n 0000163999 00000 n 0000001373 00000 n 0000001397 00000 n 0000044161 00000 n 0000163924 00000 n 0000001443 00000 n 0000001470 00000 n 0000002756 00000 n 0000003003 00000 n 0000003154 00000 n 0000003305 00000 n 0000003461 00000 n 0000003617 00000 n 0000003769 00000 n 0000003925 00000 n 0000004081 00000 n 0000004237 00000 n 0000004392 00000 n 0000004548 00000 n 0000004704 00000 n 0000004854 00000 n 0000005005 00000 n 0000005156 00000 n 0000005307 00000 n 0000005458 00000 n 0000005607 00000 n 0000005998 00000 n 0000001520 00000 n 0000005758 00000 n 0000005818 00000 n 0000162003 00000 n 0000161861 00000 n 0000161432 00000 n 0000005878 00000 n 0000161288 00000 n 0000161718 00000 n 0000162999 00000 n 0000163430 00000 n 0000008538 00000 n 0000008709 00000 n 0000008882 00000 n 0000009068 00000 n 0000009255 00000 n 0000009424 00000 n 0000009884 00000 n 0000008366 00000 n 0000006130 00000 n 0000009576 00000 n 0000162569 00000 n 0000162286 00000 n 0000163143 00000 n 0000009760 00000 n 0000009822 00000 n 0000012965 00000 n 0000013122 00000 n 0000016439 00000 n 0000013524 00000 n 0000012825 00000 n 0000010031 00000 n 0000013276 00000 n 0000162145 00000 n 0000013338 00000 n 0000162427 00000 n 0000013400 00000 n 0000163287 00000 n 0000013462 00000 n 0000016596 00000 n 0000016831 00000 n 0000016299 00000 n 0000013672 00000 n 0000016769 00000 n 0000019200 00000 n 0000018964 00000 n 0000016940 00000 n 0000019076 00000 n 0000161575 00000 n 0000019138 00000 n 0000021840 00000 n 0000022303 00000 n 0000021708 00000 n 0000019335 00000 n 0000021994 00000 n 0000022117 00000 n 0000022179 00000 n 0000022241 00000 n 0000024384 00000 n 0000024860 00000 n 0000024252 00000 n 0000022489 00000 n 0000024551 00000 n 0000024613 00000 n 0000024736 00000 n 0000024798 00000 n 0000163546 00000 n 0000026247 00000 n 0000026897 00000 n 0000026115 00000 n 0000024995 00000 n 0000026404 00000 n 0000026466 00000 n 0000026589 00000 n 0000026651 00000 n 0000026713 00000 n 0000026835 00000 n 0000029239 00000 n 0000028695 00000 n 0000027032 00000 n 0000028807 00000 n 0000028869 00000 n 0000162855 00000 n 0000028931 00000 n 0000029054 00000 n 0000029116 00000 n 0000029178 00000 n 0000030908 00000 n 0000031680 00000 n 0000030776 00000 n 0000029387 00000 n 0000031062 00000 n 0000031185 00000 n 0000031247 00000 n 0000031309 00000 n 0000031432 00000 n 0000031494 00000 n 0000031556 00000 n 0000031618 00000 n 0000033630 00000 n 0000034153 00000 n 0000033498 00000 n 0000031866 00000 n 0000033784 00000 n 0000033907 00000 n 0000033968 00000 n 0000034030 00000 n 0000036281 00000 n 0000036046 00000 n 0000034288 00000 n 0000036158 00000 n 0000162712 00000 n 0000039261 00000 n 0000039415 00000 n 0000039572 00000 n 0000039729 00000 n 0000039886 00000 n 0000040289 00000 n 0000039097 00000 n 0000036403 00000 n 0000040043 00000 n 0000040227 00000 n 0000163663 00000 n 0000043259 00000 n 0000043687 00000 n 0000043870 00000 n 0000044222 00000 n 0000043103 00000 n 0000040475 00000 n 0000044038 00000 n 0000043473 00000 n 0000046955 00000 n 0000046781 00000 n 0000044344 00000 n 0000046893 00000 n 0000049878 00000 n 0000049704 00000 n 0000047077 00000 n 0000049816 00000 n 0000051858 00000 n 0000051684 00000 n 0000050000 00000 n 0000051796 00000 n 0000051968 00000 n 0000051991 00000 n 0000052118 00000 n 0000052141 00000 n 0000052652 00000 n 0000053331 00000 n 0000053452 00000 n 0000053909 00000 n 0000054026 00000 n 0000054250 00000 n 0000054641 00000 n 0000055273 00000 n 0000055894 00000 n 0000056337 00000 n 0000056773 00000 n 0000057220 00000 n 0000066619 00000 n 0000066963 00000 n 0000073880 00000 n 0000074201 00000 n 0000075843 00000 n 0000076069 00000 n 0000092783 00000 n 0000093312 00000 n 0000099132 00000 n 0000099430 00000 n 0000104344 00000 n 0000104608 00000 n 0000106987 00000 n 0000107224 00000 n 0000109593 00000 n 0000109830 00000 n 0000118793 00000 n 0000119154 00000 n 0000125454 00000 n 0000125741 00000 n 0000126948 00000 n 0000127175 00000 n 0000130658 00000 n 0000130897 00000 n 0000144252 00000 n 0000144772 00000 n 0000151342 00000 n 0000151624 00000 n 0000160935 00000 n 0000163772 00000 n 0000163850 00000 n 0000165391 00000 n 0000165578 00000 n 0000165744 00000 n 0000165911 00000 n 0000166073 00000 n 0000166255 00000 n 0000166455 00000 n 0000166675 00000 n 0000166941 00000 n 0000167207 00000 n 0000167473 00000 n 0000167739 00000 n 0000167915 00000 n 0000168033 00000 n 0000168161 00000 n 0000168252 00000 n 0000168290 00000 n 0000168417 00000 n trailer << /Size 302 /Root 300 0 R /Info 301 0 R /ID [ ] >> startxref 168895 %%EOF mcrl2-201210.1/3rd-party/gl2ps/COPYING.LGPL000664 001751 001751 00000061424 12042421220 020567 0ustar00jenkinsjenkins000000 000000 GNU LIBRARY GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1991 Free Software Foundation, Inc. 675 Mass Ave, Cambridge, MA 02139, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the library GPL. It is numbered 2 because it goes with version 2 of the ordinary GPL.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Library General Public License, applies to some specially designated Free Software Foundation software, and to any other libraries whose authors decide to use it. You can use it for your libraries, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library, or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link a program with the library, you must provide complete object files to the recipients so that they can relink them with the library, after making changes to the library and recompiling it. And you must show them these terms so they know their rights. Our method of protecting your rights has two steps: (1) copyright the library, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the library. Also, for each distributor's protection, we want to make certain that everyone understands that there is no warranty for this free library. If the library is modified by someone else and passed on, we want its recipients to know that what they have is not the original version, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that companies distributing free software will individually obtain patent licenses, thus in effect transforming the program into proprietary software. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License, which was designed for utility programs. This license, the GNU Library General Public License, applies to certain designated libraries. This license is quite different from the ordinary one; be sure to read it in full, and don't assume that anything in it is the same as in the ordinary license. The reason we have a separate public license for some libraries is that they blur the distinction we usually make between modifying or adding to a program and simply using it. Linking a program with a library, without changing the library, is in some sense simply using the library, and is analogous to running a utility program or application program. However, in a textual and legal sense, the linked executable is a combined work, a derivative of the original library, and the ordinary General Public License treats it as such. Because of this blurred distinction, using the ordinary General Public License for libraries did not effectively promote software sharing, because most developers did not use the libraries. We concluded that weaker conditions might promote sharing better. However, unrestricted linking of non-free programs would deprive the users of those programs of all benefit from the free status of the libraries themselves. This Library General Public License is intended to permit developers of non-free programs to use free libraries, while preserving your freedom as a user of such programs to change the free libraries that are incorporated in them. (We have not seen how to achieve this as regards changes in header files, but we have achieved it as regards changes in the actual functions of the Library.) The hope is that this will lead to faster development of free libraries. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, while the latter only works together with the library. Note that it is possible for a library to be covered by the ordinary General Public License rather than by this special one. GNU LIBRARY GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Library General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also compile or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. c) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. d) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Library General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS Appendix: How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Also add information on how to contact you by electronic and paper mail. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker. , 1 April 1990 Ty Coon, President of Vice That's all there is to it! mcrl2-201210.1/3rd-party/gl2ps/CMakeLists.txt000664 001751 001751 00000002033 12042421220 021526 0ustar00jenkinsjenkins000000 000000 # Authors: Frank Stappers and Aad Mathijssen # Copyright: see the accompanying file COPYING or copy at # https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING # # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) # ########## Project setup ########## project(gl2ps) cmake_minimum_required(VERSION 2.6) # ######### General setup ########## # Trick to add header files to projects in IDEs like Visual Studio and XCode FILE(GLOB HEADERS "include/gl2ps/*.h") add_custom_target(${PROJECT_NAME}_headers SOURCES ${HEADERS} ${DETAIL_HEADERS} ) include_directories(${CMAKE_SOURCE_DIR}/3rd-party/gl2ps/include/gl2ps) # actual target: add_library(${PROJECT_NAME} source/gl2ps.c ) target_link_libraries(${PROJECT_NAME} ${OPENGL_LIBRARY} ) if( mlib_FOUND ) target_link_libraries(${PROJECT_NAME} ${MLIB_LIBRARY} ) endif( mlib_FOUND ) # add install target: install(TARGETS ${PROJECT_NAME} DESTINATION ${MCRL2_LIB_DIR} COMPONENT Libraries) mcrl2-201210.1/3rd-party/gl2ps/source/gl2ps.c000664 001751 001751 00000564540 12042421220 021501 0ustar00jenkinsjenkins000000 000000 /* * GL2PS, an OpenGL to PostScript Printing Library * Copyright (C) 1999-2009 C. Geuzaine * * This program is free software; you can redistribute it and/or * modify it under the terms of either: * * a) the GNU Library General Public License as published by the Free * Software Foundation, either version 2 of the License, or (at your * option) any later version; or * * b) the GL2PS License as published by Christophe Geuzaine, either * version 2 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 either * the GNU Library General Public License or the GL2PS License for * more details. * * You should have received a copy of the GNU Library General Public * License along with this library in the file named "COPYING.LGPL"; * if not, write to the Free Software Foundation, Inc., 675 Mass Ave, * Cambridge, MA 02139, USA. * * You should have received a copy of the GL2PS License with this * library in the file named "COPYING.GL2PS"; if not, I will be glad * to provide one. * * For the latest info about gl2ps and a full list of contributors, * see http://www.geuz.org/gl2ps/. * * Please report all bugs and problems to . */ #include "gl2ps.h" #include #include #include #include #include #include #if defined(GL2PS_HAVE_ZLIB) #include #endif #if defined(GL2PS_HAVE_LIBPNG) #include #endif /********************************************************************* * * Private definitions, data structures and prototypes * *********************************************************************/ /* Workaround for building with bjam, should be in math.h */ #ifndef M_PI # define M_PI 3.14159265358979323846 /* pi */ #endif /* Magic numbers (assuming that the order of magnitude of window coordinates is 10^3) */ #define GL2PS_EPSILON 5.0e-3F #define GL2PS_ZSCALE 1000.0F #define GL2PS_ZOFFSET 5.0e-2F #define GL2PS_ZOFFSET_LARGE 20.0F #define GL2PS_ZERO(arg) (fabs(arg) < 1.e-20) /* Primitive types */ #define GL2PS_NO_TYPE -1 #define GL2PS_TEXT 1 #define GL2PS_POINT 2 #define GL2PS_LINE 3 #define GL2PS_QUADRANGLE 4 #define GL2PS_TRIANGLE 5 #define GL2PS_PIXMAP 6 #define GL2PS_IMAGEMAP 7 #define GL2PS_IMAGEMAP_WRITTEN 8 #define GL2PS_IMAGEMAP_VISIBLE 9 #define GL2PS_SPECIAL 10 /* BSP tree primitive comparison */ #define GL2PS_COINCIDENT 1 #define GL2PS_IN_FRONT_OF 2 #define GL2PS_IN_BACK_OF 3 #define GL2PS_SPANNING 4 /* 2D BSP tree primitive comparison */ #define GL2PS_POINT_COINCIDENT 0 #define GL2PS_POINT_INFRONT 1 #define GL2PS_POINT_BACK 2 /* Internal feedback buffer pass-through tokens */ #define GL2PS_BEGIN_OFFSET_TOKEN 1 #define GL2PS_END_OFFSET_TOKEN 2 #define GL2PS_BEGIN_BOUNDARY_TOKEN 3 #define GL2PS_END_BOUNDARY_TOKEN 4 #define GL2PS_BEGIN_STIPPLE_TOKEN 5 #define GL2PS_END_STIPPLE_TOKEN 6 #define GL2PS_POINT_SIZE_TOKEN 7 #define GL2PS_LINE_WIDTH_TOKEN 8 #define GL2PS_BEGIN_BLEND_TOKEN 9 #define GL2PS_END_BLEND_TOKEN 10 #define GL2PS_SRC_BLEND_TOKEN 11 #define GL2PS_DST_BLEND_TOKEN 12 #define GL2PS_IMAGEMAP_TOKEN 13 #define GL2PS_DRAW_PIXELS_TOKEN 14 #define GL2PS_TEXT_TOKEN 15 typedef enum { T_UNDEFINED = -1, T_CONST_COLOR = 1, T_VAR_COLOR = 1<<1, T_ALPHA_1 = 1<<2, T_ALPHA_LESS_1 = 1<<3, T_VAR_ALPHA = 1<<4 } GL2PS_TRIANGLE_PROPERTY; typedef GLfloat GL2PSxyz[3]; typedef GLfloat GL2PSplane[4]; typedef struct _GL2PSbsptree2d GL2PSbsptree2d; struct _GL2PSbsptree2d { GL2PSplane plane; GL2PSbsptree2d* front, *back; }; typedef struct { GLint nmax, size, incr, n; char* array; } GL2PSlist; typedef struct _GL2PSbsptree GL2PSbsptree; struct _GL2PSbsptree { GL2PSplane plane; GL2PSlist* primitives; GL2PSbsptree* front, *back; }; typedef struct { GL2PSxyz xyz; GL2PSrgba rgba; } GL2PSvertex; typedef struct { GL2PSvertex vertex[3]; int prop; } GL2PStriangle; typedef struct { GLshort fontsize; char* str, *fontname; /* Note: for a 'special' string, 'alignment' holds the format (PostScript, PDF, etc.) of the special string */ GLint alignment; GLfloat angle; } GL2PSstring; typedef struct { GLsizei width, height; /* Note: for an imagemap, 'type' indicates if it has already been written to the file or not, and 'format' indicates if it is visible or not */ GLenum format, type; GLfloat* pixels; } GL2PSimage; typedef struct _GL2PSimagemap GL2PSimagemap; struct _GL2PSimagemap { GL2PSimage* image; GL2PSimagemap* next; }; typedef struct { GLshort type, numverts; GLushort pattern; char boundary, offset, culled; GLint factor; GLfloat width; GL2PSvertex* verts; union { GL2PSstring* text; GL2PSimage* image; } data; } GL2PSprimitive; typedef struct { #if defined(GL2PS_HAVE_ZLIB) Bytef* dest, *src, *start; uLongf destLen, srcLen; #else int dummy; #endif } GL2PScompress; typedef struct { GL2PSlist* ptrlist; int gsno, fontno, imno, shno, maskshno, trgroupno; int gsobjno, fontobjno, imobjno, shobjno, maskshobjno, trgroupobjno; } GL2PSpdfgroup; typedef struct { /* General */ GLint format, sort, options, colorsize, colormode, buffersize; char* title, *producer, *filename; GLboolean boundary, blending; GLfloat* feedback, offset[2], lastlinewidth; GLint viewport[4], blendfunc[2], lastfactor; GL2PSrgba* colormap, lastrgba, threshold, bgcolor; GLushort lastpattern; GL2PSvertex lastvertex; GL2PSlist* primitives, *auxprimitives; FILE* stream; GL2PScompress* compress; GLboolean header; /* BSP-specific */ GLint maxbestroot; /* Occlusion culling-specific */ GLboolean zerosurfacearea; GL2PSbsptree2d* imagetree; GL2PSprimitive* primitivetoadd; /* PDF-specific */ size_t streamlength; GL2PSlist* pdfprimlist, *pdfgrouplist; size_t* xreflist; int objects_stack; /* available objects */ int extgs_stack; /* graphics state object number */ int font_stack; /* font object number */ int im_stack; /* image object number */ int trgroupobjects_stack; /* xobject numbers */ int shader_stack; /* shader object numbers */ int mshader_stack; /* mask shader object numbers */ /* for image map list */ GL2PSimagemap* imagemap_head; GL2PSimagemap* imagemap_tail; } GL2PScontext; typedef struct { void (*printHeader)(void); void (*printFooter)(void); void (*beginViewport)(GLint viewport[4]); GLint(*endViewport)(void); void (*printPrimitive)(void* data); void (*printFinalPrimitive)(void); const char* file_extension; const char* description; } GL2PSbackend; /* The gl2ps context. gl2ps is not thread safe (we should create a local GL2PScontext during gl2psBeginPage) */ static GL2PScontext* gl2ps = NULL; /* Need to forward-declare this one */ static GLint gl2psPrintPrimitives(void); /********************************************************************* * * Utility routines * *********************************************************************/ static void gl2psMsg(GLint level, const char* fmt, ...) { va_list args; if (!(gl2ps->options & GL2PS_SILENT)) { switch (level) { case GL2PS_INFO : fprintf(stderr, "GL2PS info: "); break; case GL2PS_WARNING : fprintf(stderr, "GL2PS warning: "); break; case GL2PS_ERROR : fprintf(stderr, "GL2PS error: "); break; } va_start(args, fmt); vfprintf(stderr, fmt, args); va_end(args); fprintf(stderr, "\n"); } /* if(level == GL2PS_ERROR) exit(1); */ } static void* gl2psMalloc(size_t size) { void* ptr; if (!size) { return NULL; } ptr = malloc(size); if (!ptr) { gl2psMsg(GL2PS_ERROR, "Couldn't allocate requested memory"); return NULL; } return ptr; } static void* gl2psRealloc(void* ptr, size_t size) { if (!size) { return NULL; } ptr = realloc(ptr, size); if (!ptr) { gl2psMsg(GL2PS_ERROR, "Couldn't reallocate requested memory"); return NULL; } return ptr; } static void gl2psFree(void* ptr) { if (!ptr) { return; } free(ptr); } static size_t gl2psWriteBigEndian(unsigned long data, size_t bytes) { size_t i; size_t size = sizeof(unsigned long); for (i = 1; i <= bytes; ++i) { fputc(0xff & (data >> (size-i) * 8), gl2ps->stream); } return bytes; } /* zlib compression helper routines */ #if defined(GL2PS_HAVE_ZLIB) static void gl2psSetupCompress(void) { gl2ps->compress = (GL2PScompress*)gl2psMalloc(sizeof(GL2PScompress)); gl2ps->compress->src = NULL; gl2ps->compress->start = NULL; gl2ps->compress->dest = NULL; gl2ps->compress->srcLen = 0; gl2ps->compress->destLen = 0; } static void gl2psFreeCompress(void) { if (!gl2ps->compress) { return; } gl2psFree(gl2ps->compress->start); gl2psFree(gl2ps->compress->dest); gl2ps->compress->src = NULL; gl2ps->compress->start = NULL; gl2ps->compress->dest = NULL; gl2ps->compress->srcLen = 0; gl2ps->compress->destLen = 0; } static int gl2psAllocCompress(unsigned int srcsize) { gl2psFreeCompress(); if (!gl2ps->compress || !srcsize) { return GL2PS_ERROR; } gl2ps->compress->srcLen = srcsize; gl2ps->compress->destLen = (int)ceil(1.001 * gl2ps->compress->srcLen + 12); gl2ps->compress->src = (Bytef*)gl2psMalloc(gl2ps->compress->srcLen); gl2ps->compress->start = gl2ps->compress->src; gl2ps->compress->dest = (Bytef*)gl2psMalloc(gl2ps->compress->destLen); return GL2PS_SUCCESS; } static void* gl2psReallocCompress(unsigned int srcsize) { if (!gl2ps->compress || !srcsize) { return NULL; } if (srcsize < gl2ps->compress->srcLen) { return gl2ps->compress->start; } gl2ps->compress->srcLen = srcsize; gl2ps->compress->destLen = (int)ceil(1.001 * gl2ps->compress->srcLen + 12); gl2ps->compress->src = (Bytef*)gl2psRealloc(gl2ps->compress->src, gl2ps->compress->srcLen); gl2ps->compress->start = gl2ps->compress->src; gl2ps->compress->dest = (Bytef*)gl2psRealloc(gl2ps->compress->dest, gl2ps->compress->destLen); return gl2ps->compress->start; } static size_t gl2psWriteBigEndianCompress(unsigned long data, size_t bytes) { size_t i; size_t size = sizeof(unsigned long); for (i = 1; i <= bytes; ++i) { *gl2ps->compress->src = (Bytef)(0xff & (data >> (size-i) * 8)); ++gl2ps->compress->src; } return bytes; } static int gl2psDeflate(void) { /* For compatibility with older zlib versions, we use compress(...) instead of compress2(..., Z_BEST_COMPRESSION) */ return compress(gl2ps->compress->dest, &gl2ps->compress->destLen, gl2ps->compress->start, gl2ps->compress->srcLen); } #endif static int gl2psPrintf(const char* fmt, ...) { int ret; va_list args; #if defined(GL2PS_HAVE_ZLIB) unsigned int oldsize = 0; static char buf[1000]; if (gl2ps->options & GL2PS_COMPRESS) { va_start(args, fmt); ret = vsprintf(buf, fmt, args); va_end(args); oldsize = gl2ps->compress->srcLen; gl2ps->compress->start = (Bytef*)gl2psReallocCompress(oldsize + ret); memcpy(gl2ps->compress->start+oldsize, buf, ret); ret = 0; } else { #endif va_start(args, fmt); ret = vfprintf(gl2ps->stream, fmt, args); va_end(args); #if defined(GL2PS_HAVE_ZLIB) } #endif return ret; } static void gl2psPrintGzipHeader() { #if defined(GL2PS_HAVE_ZLIB) char tmp[10] = {'\x1f', '\x8b', /* magic numbers: 0x1f, 0x8b */ 8, /* compression method: Z_DEFLATED */ 0, /* flags */ 0, 0, 0, 0, /* time */ 2, /* extra flags: max compression */ '\x03' }; /* OS code: 0x03 (Unix) */ if (gl2ps->options & GL2PS_COMPRESS) { gl2psSetupCompress(); /* add the gzip file header */ fwrite(tmp, 10, 1, gl2ps->stream); } #endif } static void gl2psPrintGzipFooter() { #if defined(GL2PS_HAVE_ZLIB) int n; uLong crc, len; char tmp[8]; if (gl2ps->options & GL2PS_COMPRESS) { if (Z_OK != gl2psDeflate()) { gl2psMsg(GL2PS_ERROR, "Zlib deflate error"); } else { /* determine the length of the header in the zlib stream */ n = 2; /* CMF+FLG */ if (gl2ps->compress->dest[1] & (1<<5)) { n += 4; /* DICTID */ } /* write the data, without the zlib header and footer */ fwrite(gl2ps->compress->dest+n, gl2ps->compress->destLen-(n+4), 1, gl2ps->stream); /* add the gzip file footer */ crc = crc32(0L, gl2ps->compress->start, gl2ps->compress->srcLen); for (n = 0; n < 4; ++n) { tmp[n] = (char)(crc & 0xff); crc >>= 8; } len = gl2ps->compress->srcLen; for (n = 4; n < 8; ++n) { tmp[n] = (char)(len & 0xff); len >>= 8; } fwrite(tmp, 8, 1, gl2ps->stream); } gl2psFreeCompress(); gl2psFree(gl2ps->compress); gl2ps->compress = NULL; } #endif } /* The list handling routines */ static void gl2psListRealloc(GL2PSlist* list, GLint n) { if (!list) { gl2psMsg(GL2PS_ERROR, "Cannot reallocate NULL list"); return; } if (n <= 0) { return; } if (!list->array) { list->nmax = n; list->array = (char*)gl2psMalloc(list->nmax * list->size); } else { if (n > list->nmax) { list->nmax = ((n - 1) / list->incr + 1) * list->incr; list->array = (char*)gl2psRealloc(list->array, list->nmax * list->size); } } } static GL2PSlist* gl2psListCreate(GLint n, GLint incr, GLint size) { GL2PSlist* list; if (n < 0) { n = 0; } if (incr <= 0) { incr = 1; } list = (GL2PSlist*)gl2psMalloc(sizeof(GL2PSlist)); list->nmax = 0; list->incr = incr; list->size = size; list->n = 0; list->array = NULL; gl2psListRealloc(list, n); return list; } static void gl2psListReset(GL2PSlist* list) { if (!list) { return; } list->n = 0; } static void gl2psListDelete(GL2PSlist* list) { if (!list) { return; } gl2psFree(list->array); gl2psFree(list); } static void gl2psListAdd(GL2PSlist* list, void* data) { if (!list) { gl2psMsg(GL2PS_ERROR, "Cannot add into unallocated list"); return; } list->n++; gl2psListRealloc(list, list->n); memcpy(&list->array[(list->n - 1) * list->size], data, list->size); } static int gl2psListNbr(GL2PSlist* list) { if (!list) { return 0; } return list->n; } static void* gl2psListPointer(GL2PSlist* list, GLint index) { if (!list) { gl2psMsg(GL2PS_ERROR, "Cannot point into unallocated list"); return NULL; } if ((index < 0) || (index >= list->n)) { gl2psMsg(GL2PS_ERROR, "Wrong list index in gl2psListPointer"); return NULL; } return &list->array[index * list->size]; } static void gl2psListSort(GL2PSlist* list, int (*fcmp)(const void* a, const void* b)) { if (!list) { return; } qsort(list->array, list->n, list->size, fcmp); } static void gl2psListAction(GL2PSlist* list, void (*action)(void* data)) { GLint i; for (i = 0; i < gl2psListNbr(list); i++) { (*action)(gl2psListPointer(list, i)); } } static void gl2psListActionInverse(GL2PSlist* list, void (*action)(void* data)) { GLint i; for (i = gl2psListNbr(list); i > 0; i--) { (*action)(gl2psListPointer(list, i-1)); } } #if defined(GL2PS_HAVE_LIBPNG) static void gl2psListRead(GL2PSlist* list, int index, void* data) { if ((index < 0) || (index >= list->n)) { gl2psMsg(GL2PS_ERROR, "Wrong list index in gl2psListRead"); } memcpy(data, &list->array[index * list->size], list->size); } static void gl2psEncodeBase64Block(unsigned char in[3], unsigned char out[4], int len) { static const char cb64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; out[0] = cb64[ in[0] >> 2 ]; out[1] = cb64[((in[0] & 0x03) << 4) | ((in[1] & 0xf0) >> 4) ]; out[2] = (len > 1) ? cb64[((in[1] & 0x0f) << 2) | ((in[2] & 0xc0) >> 6) ] : '='; out[3] = (len > 2) ? cb64[ in[2] & 0x3f ] : '='; } static void gl2psListEncodeBase64(GL2PSlist* list) { unsigned char* buffer, in[3], out[4]; int i, n, index, len; n = list->n * list->size; buffer = (unsigned char*)gl2psMalloc(n * sizeof(unsigned char)); memcpy(buffer, list->array, n * sizeof(unsigned char)); gl2psListReset(list); index = 0; while (index < n) { len = 0; for (i = 0; i < 3; i++) { if (index < n) { in[i] = buffer[index]; len++; } else { in[i] = 0; } index++; } if (len) { gl2psEncodeBase64Block(in, out, len); for (i = 0; i < 4; i++) { gl2psListAdd(list, &out[i]); } } } gl2psFree(buffer); } #endif /* Helpers for rgba colors */ static GLboolean gl2psSameColor(GL2PSrgba rgba1, GL2PSrgba rgba2) { if (!GL2PS_ZERO(rgba1[0] - rgba2[0]) || !GL2PS_ZERO(rgba1[1] - rgba2[1]) || !GL2PS_ZERO(rgba1[2] - rgba2[2])) { return GL_FALSE; } return GL_TRUE; } static GLboolean gl2psVertsSameColor(const GL2PSprimitive* prim) { int i; for (i = 1; i < prim->numverts; i++) { if (!gl2psSameColor(prim->verts[0].rgba, prim->verts[i].rgba)) { return GL_FALSE; } } return GL_TRUE; } static GLboolean gl2psSameColorThreshold(int n, GL2PSrgba rgba[], GL2PSrgba threshold) { int i; if (n < 2) { return GL_TRUE; } for (i = 1; i < n; i++) { if (fabs(rgba[0][0] - rgba[i][0]) > threshold[0] || fabs(rgba[0][1] - rgba[i][1]) > threshold[1] || fabs(rgba[0][2] - rgba[i][2]) > threshold[2]) { return GL_FALSE; } } return GL_TRUE; } static void gl2psSetLastColor(GL2PSrgba rgba) { int i; for (i = 0; i < 3; ++i) { gl2ps->lastrgba[i] = rgba[i]; } } static GLfloat gl2psGetRGB(GL2PSimage* im, GLuint x, GLuint y, GLfloat* red, GLfloat* green, GLfloat* blue) { GLsizei width = im->width; GLsizei height = im->height; GLfloat* pixels = im->pixels; GLfloat* pimag; /* OpenGL image is from down to up, PS image is up to down */ switch (im->format) { case GL_RGBA: pimag = pixels + 4 * (width * (height - 1 - y) + x); break; case GL_RGB: default: pimag = pixels + 3 * (width * (height - 1 - y) + x); break; } *red = *pimag; pimag++; *green = *pimag; pimag++; *blue = *pimag; pimag++; return (im->format == GL_RGBA) ? *pimag : 1.0F; } /* Helper routines for pixmaps */ static GL2PSimage* gl2psCopyPixmap(GL2PSimage* im) { int size; GL2PSimage* image = (GL2PSimage*)gl2psMalloc(sizeof(GL2PSimage)); image->width = im->width; image->height = im->height; image->format = im->format; image->type = im->type; switch (image->format) { case GL_RGBA: size = image->height * image->width * 4 * sizeof(GLfloat); break; case GL_RGB: default: size = image->height * image->width * 3 * sizeof(GLfloat); break; } image->pixels = (GLfloat*)gl2psMalloc(size); memcpy(image->pixels, im->pixels, size); return image; } static void gl2psFreePixmap(GL2PSimage* im) { if (!im) { return; } gl2psFree(im->pixels); gl2psFree(im); } #if defined(GL2PS_HAVE_LIBPNG) #if !defined(png_jmpbuf) # define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf) #endif static void gl2psUserWritePNG(png_structp png_ptr, png_bytep data, png_size_t length) { unsigned int i; GL2PSlist* png = (GL2PSlist*)png_get_io_ptr(png_ptr); for (i = 0; i < length; i++) { gl2psListAdd(png, &data[i]); } } static void gl2psUserFlushPNG(png_structp png_ptr) { } static void gl2psConvertPixmapToPNG(GL2PSimage* pixmap, GL2PSlist* png) { png_structp png_ptr; png_infop info_ptr; unsigned char* row_data; GLfloat dr, dg, db; int row, col; if (!(png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL))) { return; } if (!(info_ptr = png_create_info_struct(png_ptr))) { png_destroy_write_struct(&png_ptr, NULL); return; } if (setjmp(png_jmpbuf(png_ptr))) { png_destroy_write_struct(&png_ptr, &info_ptr); return; } png_set_write_fn(png_ptr, (void*)png, gl2psUserWritePNG, gl2psUserFlushPNG); png_set_compression_level(png_ptr, Z_DEFAULT_COMPRESSION); png_set_IHDR(png_ptr, info_ptr, pixmap->width, pixmap->height, 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); png_write_info(png_ptr, info_ptr); row_data = (unsigned char*)gl2psMalloc(3 * pixmap->width * sizeof(unsigned char)); for (row = 0; row < pixmap->height; row++) { for (col = 0; col < pixmap->width; col++) { gl2psGetRGB(pixmap, col, row, &dr, &dg, &db); row_data[3*col] = (unsigned char)(255. * dr); row_data[3*col+1] = (unsigned char)(255. * dg); row_data[3*col+2] = (unsigned char)(255. * db); } png_write_row(png_ptr, (png_bytep)row_data); } gl2psFree(row_data); png_write_end(png_ptr, info_ptr); png_destroy_write_struct(&png_ptr, &info_ptr); } #endif /* Helper routines for text strings */ static GLint gl2psAddText(GLint type, const char* str, const char* fontname, GLshort fontsize, GLint alignment, GLfloat angle) { GLfloat pos[4]; GL2PSprimitive* prim; GLboolean valid; if (!gl2ps || !str || !fontname) { return GL2PS_UNINITIALIZED; } if (gl2ps->options & GL2PS_NO_TEXT) { return GL2PS_SUCCESS; } glGetBooleanv(GL_CURRENT_RASTER_POSITION_VALID, &valid); if (GL_FALSE == valid) { return GL2PS_SUCCESS; /* the primitive is culled */ } glGetFloatv(GL_CURRENT_RASTER_POSITION, pos); prim = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive)); prim->type = type; prim->boundary = 0; prim->numverts = 1; prim->verts = (GL2PSvertex*)gl2psMalloc(sizeof(GL2PSvertex)); prim->verts[0].xyz[0] = pos[0]; prim->verts[0].xyz[1] = pos[1]; prim->verts[0].xyz[2] = pos[2]; prim->culled = 0; prim->offset = 0; prim->pattern = 0; prim->factor = 0; prim->width = 1; glGetFloatv(GL_CURRENT_RASTER_COLOR, prim->verts[0].rgba); prim->data.text = (GL2PSstring*)gl2psMalloc(sizeof(GL2PSstring)); prim->data.text->str = (char*)gl2psMalloc((strlen(str)+1)*sizeof(char)); strcpy(prim->data.text->str, str); prim->data.text->fontname = (char*)gl2psMalloc((strlen(fontname)+1)*sizeof(char)); strcpy(prim->data.text->fontname, fontname); prim->data.text->fontsize = fontsize; prim->data.text->alignment = alignment; prim->data.text->angle = angle; gl2psListAdd(gl2ps->auxprimitives, &prim); glPassThrough(GL2PS_TEXT_TOKEN); return GL2PS_SUCCESS; } static GL2PSstring* gl2psCopyText(GL2PSstring* t) { GL2PSstring* text = (GL2PSstring*)gl2psMalloc(sizeof(GL2PSstring)); text->str = (char*)gl2psMalloc((strlen(t->str)+1)*sizeof(char)); strcpy(text->str, t->str); text->fontname = (char*)gl2psMalloc((strlen(t->fontname)+1)*sizeof(char)); strcpy(text->fontname, t->fontname); text->fontsize = t->fontsize; text->alignment = t->alignment; text->angle = t->angle; return text; } static void gl2psFreeText(GL2PSstring* text) { if (!text) { return; } gl2psFree(text->str); gl2psFree(text->fontname); gl2psFree(text); } /* Helpers for blending modes */ static GLboolean gl2psSupportedBlendMode(GLenum sfactor, GLenum dfactor) { /* returns TRUE if gl2ps supports the argument combination: only two blending modes have been implemented so far */ if ((sfactor == GL_SRC_ALPHA && dfactor == GL_ONE_MINUS_SRC_ALPHA) || (sfactor == GL_ONE && dfactor == GL_ZERO)) { return GL_TRUE; } return GL_FALSE; } static void gl2psAdaptVertexForBlending(GL2PSvertex* v) { /* Transforms vertex depending on the actual blending function - currently the vertex v is considered as source vertex and his alpha value is changed to 1.0 if source blending GL_ONE is active. This might be extended in the future */ if (!v || !gl2ps) { return; } if (gl2ps->options & GL2PS_NO_BLENDING || !gl2ps->blending) { v->rgba[3] = 1.0F; return; } switch (gl2ps->blendfunc[0]) { case GL_ONE: v->rgba[3] = 1.0F; break; default: break; } } static void gl2psAssignTriangleProperties(GL2PStriangle* t) { /* int i; */ t->prop = T_VAR_COLOR; /* Uncommenting the following lines activates an even more fine grained distinction between triangle types - please don't delete, a remarkable amount of PDF handling code inside this file depends on it if activated */ /* t->prop = T_CONST_COLOR; for(i = 0; i < 3; ++i){ if(!GL2PS_ZERO(t->vertex[0].rgba[i] - t->vertex[1].rgba[i]) || !GL2PS_ZERO(t->vertex[1].rgba[i] - t->vertex[2].rgba[i])){ t->prop = T_VAR_COLOR; break; } } */ if (!GL2PS_ZERO(t->vertex[0].rgba[3] - t->vertex[1].rgba[3]) || !GL2PS_ZERO(t->vertex[1].rgba[3] - t->vertex[2].rgba[3])) { t->prop |= T_VAR_ALPHA; } else { if (t->vertex[0].rgba[3] < 1) { t->prop |= T_ALPHA_LESS_1; } else { t->prop |= T_ALPHA_1; } } } static void gl2psFillTriangleFromPrimitive(GL2PStriangle* t, GL2PSprimitive* p, GLboolean assignprops) { t->vertex[0] = p->verts[0]; t->vertex[1] = p->verts[1]; t->vertex[2] = p->verts[2]; if (GL_TRUE == assignprops) { gl2psAssignTriangleProperties(t); } } static void gl2psInitTriangle(GL2PStriangle* t) { int i; GL2PSvertex vertex = { {-1.0F, -1.0F, -1.0F}, {-1.0F, -1.0F, -1.0F, -1.0F} }; for (i = 0; i < 3; i++) { t->vertex[i] = vertex; } t->prop = T_UNDEFINED; } /* Miscellaneous helper routines */ static GL2PSprimitive* gl2psCopyPrimitive(GL2PSprimitive* p) { GL2PSprimitive* prim; if (!p) { gl2psMsg(GL2PS_ERROR, "Trying to copy an empty primitive"); return NULL; } prim = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive)); prim->type = p->type; prim->numverts = p->numverts; prim->boundary = p->boundary; prim->offset = p->offset; prim->pattern = p->pattern; prim->factor = p->factor; prim->culled = p->culled; prim->width = p->width; prim->verts = (GL2PSvertex*)gl2psMalloc(p->numverts*sizeof(GL2PSvertex)); memcpy(prim->verts, p->verts, p->numverts * sizeof(GL2PSvertex)); switch (prim->type) { case GL2PS_PIXMAP : prim->data.image = gl2psCopyPixmap(p->data.image); break; case GL2PS_TEXT : case GL2PS_SPECIAL : prim->data.text = gl2psCopyText(p->data.text); break; default: break; } return prim; } static GLboolean gl2psSamePosition(GL2PSxyz p1, GL2PSxyz p2) { if (!GL2PS_ZERO(p1[0] - p2[0]) || !GL2PS_ZERO(p1[1] - p2[1]) || !GL2PS_ZERO(p1[2] - p2[2])) { return GL_FALSE; } return GL_TRUE; } /********************************************************************* * * 3D sorting routines * *********************************************************************/ static GLfloat gl2psComparePointPlane(GL2PSxyz point, GL2PSplane plane) { return (plane[0] * point[0] + plane[1] * point[1] + plane[2] * point[2] + plane[3]); } static GLfloat gl2psPsca(GLfloat* a, GLfloat* b) { return (a[0]*b[0] + a[1]*b[1] + a[2]*b[2]); } static void gl2psPvec(GLfloat* a, GLfloat* b, GLfloat* c) { c[0] = a[1]*b[2] - a[2]*b[1]; c[1] = a[2]*b[0] - a[0]*b[2]; c[2] = a[0]*b[1] - a[1]*b[0]; } static GLfloat gl2psNorm(GLfloat* a) { return (GLfloat)sqrt(a[0]*a[0] + a[1]*a[1] + a[2]*a[2]); } static void gl2psGetNormal(GLfloat* a, GLfloat* b, GLfloat* c) { GLfloat norm; gl2psPvec(a, b, c); if (!GL2PS_ZERO(norm = gl2psNorm(c))) { c[0] = c[0] / norm; c[1] = c[1] / norm; c[2] = c[2] / norm; } else { /* The plane is still wrong despite our tests in gl2psGetPlane. Let's return a dummy value for now (this is a hack: we should do more intelligent tests in GetPlane) */ c[0] = c[1] = 0.0F; c[2] = 1.0F; } } static void gl2psGetPlane(GL2PSprimitive* prim, GL2PSplane plane) { GL2PSxyz v = {0.0F, 0.0F, 0.0F}, w = {0.0F, 0.0F, 0.0F}; switch (prim->type) { case GL2PS_TRIANGLE : case GL2PS_QUADRANGLE : v[0] = prim->verts[1].xyz[0] - prim->verts[0].xyz[0]; v[1] = prim->verts[1].xyz[1] - prim->verts[0].xyz[1]; v[2] = prim->verts[1].xyz[2] - prim->verts[0].xyz[2]; w[0] = prim->verts[2].xyz[0] - prim->verts[0].xyz[0]; w[1] = prim->verts[2].xyz[1] - prim->verts[0].xyz[1]; w[2] = prim->verts[2].xyz[2] - prim->verts[0].xyz[2]; if ((GL2PS_ZERO(v[0]) && GL2PS_ZERO(v[1]) && GL2PS_ZERO(v[2])) || (GL2PS_ZERO(w[0]) && GL2PS_ZERO(w[1]) && GL2PS_ZERO(w[2]))) { plane[0] = plane[1] = 0.0F; plane[2] = 1.0F; plane[3] = -prim->verts[0].xyz[2]; } else { gl2psGetNormal(v, w, plane); plane[3] = - plane[0] * prim->verts[0].xyz[0] - plane[1] * prim->verts[0].xyz[1] - plane[2] * prim->verts[0].xyz[2]; } break; case GL2PS_LINE : v[0] = prim->verts[1].xyz[0] - prim->verts[0].xyz[0]; v[1] = prim->verts[1].xyz[1] - prim->verts[0].xyz[1]; v[2] = prim->verts[1].xyz[2] - prim->verts[0].xyz[2]; if (GL2PS_ZERO(v[0]) && GL2PS_ZERO(v[1]) && GL2PS_ZERO(v[2])) { plane[0] = plane[1] = 0.0F; plane[2] = 1.0F; plane[3] = -prim->verts[0].xyz[2]; } else { if (GL2PS_ZERO(v[0])) { w[0] = 1.0F; } else if (GL2PS_ZERO(v[1])) { w[1] = 1.0F; } else { w[2] = 1.0F; } gl2psGetNormal(v, w, plane); plane[3] = - plane[0] * prim->verts[0].xyz[0] - plane[1] * prim->verts[0].xyz[1] - plane[2] * prim->verts[0].xyz[2]; } break; case GL2PS_POINT : case GL2PS_PIXMAP : case GL2PS_TEXT : case GL2PS_SPECIAL : case GL2PS_IMAGEMAP: plane[0] = plane[1] = 0.0F; plane[2] = 1.0F; plane[3] = -prim->verts[0].xyz[2]; break; default : gl2psMsg(GL2PS_ERROR, "Unknown primitive type in BSP tree"); plane[0] = plane[1] = plane[3] = 0.0F; plane[2] = 1.0F; break; } } static void gl2psCutEdge(GL2PSvertex* a, GL2PSvertex* b, GL2PSplane plane, GL2PSvertex* c) { GL2PSxyz v; GLfloat sect, psca; v[0] = b->xyz[0] - a->xyz[0]; v[1] = b->xyz[1] - a->xyz[1]; v[2] = b->xyz[2] - a->xyz[2]; if (!GL2PS_ZERO(psca = gl2psPsca(plane, v))) { sect = -gl2psComparePointPlane(a->xyz, plane) / psca; } else { sect = 0.0F; } c->xyz[0] = a->xyz[0] + v[0] * sect; c->xyz[1] = a->xyz[1] + v[1] * sect; c->xyz[2] = a->xyz[2] + v[2] * sect; c->rgba[0] = (1 - sect) * a->rgba[0] + sect * b->rgba[0]; c->rgba[1] = (1 - sect) * a->rgba[1] + sect * b->rgba[1]; c->rgba[2] = (1 - sect) * a->rgba[2] + sect * b->rgba[2]; c->rgba[3] = (1 - sect) * a->rgba[3] + sect * b->rgba[3]; } static void gl2psCreateSplitPrimitive(GL2PSprimitive* parent, GL2PSplane plane, GL2PSprimitive* child, GLshort numverts, GLshort* index0, GLshort* index1) { GLshort i; if (parent->type == GL2PS_IMAGEMAP) { child->type = GL2PS_IMAGEMAP; child->data.image = parent->data.image; } else { if (numverts > 4) { gl2psMsg(GL2PS_WARNING, "%d vertices in polygon", numverts); numverts = 4; } switch (numverts) { case 1 : child->type = GL2PS_POINT; break; case 2 : child->type = GL2PS_LINE; break; case 3 : child->type = GL2PS_TRIANGLE; break; case 4 : child->type = GL2PS_QUADRANGLE; break; default: child->type = GL2PS_NO_TYPE; break; } } child->boundary = 0; /* FIXME: not done! */ child->culled = parent->culled; child->offset = parent->offset; child->pattern = parent->pattern; child->factor = parent->factor; child->width = parent->width; child->numverts = numverts; child->verts = (GL2PSvertex*)gl2psMalloc(numverts * sizeof(GL2PSvertex)); for (i = 0; i < numverts; i++) { if (index1[i] < 0) { child->verts[i] = parent->verts[index0[i]]; } else { gl2psCutEdge(&parent->verts[index0[i]], &parent->verts[index1[i]], plane, &child->verts[i]); } } } static void gl2psAddIndex(GLshort* index0, GLshort* index1, GLshort* nb, GLshort i, GLshort j) { GLint k; for (k = 0; k < *nb; k++) { if ((index0[k] == i && index1[k] == j) || (index1[k] == i && index0[k] == j)) { return; } } index0[*nb] = i; index1[*nb] = j; (*nb)++; } static GLshort gl2psGetIndex(GLshort i, GLshort num) { return (i < num - 1) ? i + 1 : 0; } static GLint gl2psTestSplitPrimitive(GL2PSprimitive* prim, GL2PSplane plane) { GLint type = GL2PS_COINCIDENT; GLshort i, j; GLfloat d[5]; for (i = 0; i < prim->numverts; i++) { d[i] = gl2psComparePointPlane(prim->verts[i].xyz, plane); } if (prim->numverts < 2) { return 0; } else { for (i = 0; i < prim->numverts; i++) { j = gl2psGetIndex(i, prim->numverts); if (d[j] > GL2PS_EPSILON) { if (type == GL2PS_COINCIDENT) { type = GL2PS_IN_BACK_OF; } else if (type != GL2PS_IN_BACK_OF) { return 1; } if (d[i] < -GL2PS_EPSILON) { return 1; } } else if (d[j] < -GL2PS_EPSILON) { if (type == GL2PS_COINCIDENT) { type = GL2PS_IN_FRONT_OF; } else if (type != GL2PS_IN_FRONT_OF) { return 1; } if (d[i] > GL2PS_EPSILON) { return 1; } } } } return 0; } static GLint gl2psSplitPrimitive(GL2PSprimitive* prim, GL2PSplane plane, GL2PSprimitive** front, GL2PSprimitive** back) { GLshort i, j, in = 0, out = 0, in0[5], in1[5], out0[5], out1[5]; GLint type; GLfloat d[5]; type = GL2PS_COINCIDENT; for (i = 0; i < prim->numverts; i++) { d[i] = gl2psComparePointPlane(prim->verts[i].xyz, plane); } switch (prim->type) { case GL2PS_POINT : if (d[0] > GL2PS_EPSILON) { type = GL2PS_IN_BACK_OF; } else if (d[0] < -GL2PS_EPSILON) { type = GL2PS_IN_FRONT_OF; } else { type = GL2PS_COINCIDENT; } break; default : for (i = 0; i < prim->numverts; i++) { j = gl2psGetIndex(i, prim->numverts); if (d[j] > GL2PS_EPSILON) { if (type == GL2PS_COINCIDENT) { type = GL2PS_IN_BACK_OF; } else if (type != GL2PS_IN_BACK_OF) { type = GL2PS_SPANNING; } if (d[i] < -GL2PS_EPSILON) { gl2psAddIndex(in0, in1, &in, i, j); gl2psAddIndex(out0, out1, &out, i, j); type = GL2PS_SPANNING; } gl2psAddIndex(out0, out1, &out, j, -1); } else if (d[j] < -GL2PS_EPSILON) { if (type == GL2PS_COINCIDENT) { type = GL2PS_IN_FRONT_OF; } else if (type != GL2PS_IN_FRONT_OF) { type = GL2PS_SPANNING; } if (d[i] > GL2PS_EPSILON) { gl2psAddIndex(in0, in1, &in, i, j); gl2psAddIndex(out0, out1, &out, i, j); type = GL2PS_SPANNING; } gl2psAddIndex(in0, in1, &in, j, -1); } else { gl2psAddIndex(in0, in1, &in, j, -1); gl2psAddIndex(out0, out1, &out, j, -1); } } break; } if (type == GL2PS_SPANNING) { *back = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive)); *front = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive)); gl2psCreateSplitPrimitive(prim, plane, *back, out, out0, out1); gl2psCreateSplitPrimitive(prim, plane, *front, in, in0, in1); } return type; } static void gl2psDivideQuad(GL2PSprimitive* quad, GL2PSprimitive** t1, GL2PSprimitive** t2) { *t1 = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive)); *t2 = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive)); (*t1)->type = (*t2)->type = GL2PS_TRIANGLE; (*t1)->numverts = (*t2)->numverts = 3; (*t1)->culled = (*t2)->culled = quad->culled; (*t1)->offset = (*t2)->offset = quad->offset; (*t1)->pattern = (*t2)->pattern = quad->pattern; (*t1)->factor = (*t2)->factor = quad->factor; (*t1)->width = (*t2)->width = quad->width; (*t1)->verts = (GL2PSvertex*)gl2psMalloc(3 * sizeof(GL2PSvertex)); (*t2)->verts = (GL2PSvertex*)gl2psMalloc(3 * sizeof(GL2PSvertex)); (*t1)->verts[0] = quad->verts[0]; (*t1)->verts[1] = quad->verts[1]; (*t1)->verts[2] = quad->verts[2]; (*t1)->boundary = ((quad->boundary & 1) ? 1 : 0) | ((quad->boundary & 2) ? 2 : 0); (*t2)->verts[0] = quad->verts[0]; (*t2)->verts[1] = quad->verts[2]; (*t2)->verts[2] = quad->verts[3]; (*t2)->boundary = ((quad->boundary & 4) ? 2 : 0) | ((quad->boundary & 4) ? 2 : 0); } static int gl2psCompareDepth(const void* a, const void* b) { GL2PSprimitive* q, *w; GLfloat dq = 0.0F, dw = 0.0F, diff; int i; q = *(GL2PSprimitive**)a; w = *(GL2PSprimitive**)b; for (i = 0; i < q->numverts; i++) { dq += q->verts[i].xyz[2]; } dq /= (GLfloat)q->numverts; for (i = 0; i < w->numverts; i++) { dw += w->verts[i].xyz[2]; } dw /= (GLfloat)w->numverts; diff = dq - dw; if (diff > 0.) { return -1; } else if (diff < 0.) { return 1; } else { return 0; } } static int gl2psTrianglesFirst(const void* a, const void* b) { GL2PSprimitive* q, *w; q = *(GL2PSprimitive**)a; w = *(GL2PSprimitive**)b; return (q->type < w->type ? 1 : -1); } static GLint gl2psFindRoot(GL2PSlist* primitives, GL2PSprimitive** root) { GLint i, j, count, best = 1000000, index = 0; GL2PSprimitive* prim1, *prim2; GL2PSplane plane; GLint maxp; if (!gl2psListNbr(primitives)) { gl2psMsg(GL2PS_ERROR, "Cannot fint root in empty primitive list"); return 0; } *root = *(GL2PSprimitive**)gl2psListPointer(primitives, 0); if (gl2ps->options & GL2PS_BEST_ROOT) { maxp = gl2psListNbr(primitives); if (maxp > gl2ps->maxbestroot) { maxp = gl2ps->maxbestroot; } for (i = 0; i < maxp; i++) { prim1 = *(GL2PSprimitive**)gl2psListPointer(primitives, i); gl2psGetPlane(prim1, plane); count = 0; for (j = 0; j < gl2psListNbr(primitives); j++) { if (j != i) { prim2 = *(GL2PSprimitive**)gl2psListPointer(primitives, j); count += gl2psTestSplitPrimitive(prim2, plane); } if (count > best) { break; } } if (count < best) { best = count; index = i; *root = prim1; if (!count) { return index; } } } /* if(index) gl2psMsg(GL2PS_INFO, "GL2PS_BEST_ROOT was worth it: %d", index); */ return index; } else { return 0; } } static void gl2psFreeImagemap(GL2PSimagemap* list) { GL2PSimagemap* next; while (list != NULL) { next = list->next; gl2psFree(list->image->pixels); gl2psFree(list->image); gl2psFree(list); list = next; } } static void gl2psFreePrimitive(void* data) { GL2PSprimitive* q; q = *(GL2PSprimitive**)data; gl2psFree(q->verts); if (q->type == GL2PS_TEXT || q->type == GL2PS_SPECIAL) { gl2psFreeText(q->data.text); } else if (q->type == GL2PS_PIXMAP) { gl2psFreePixmap(q->data.image); } gl2psFree(q); } static void gl2psAddPrimitiveInList(GL2PSprimitive* prim, GL2PSlist* list) { GL2PSprimitive* t1, *t2; if (prim->type != GL2PS_QUADRANGLE) { gl2psListAdd(list, &prim); } else { gl2psDivideQuad(prim, &t1, &t2); gl2psListAdd(list, &t1); gl2psListAdd(list, &t2); gl2psFreePrimitive(&prim); } } static void gl2psFreeBspTree(GL2PSbsptree** tree) { if (*tree) { if ((*tree)->back) { gl2psFreeBspTree(&(*tree)->back); } if ((*tree)->primitives) { gl2psListAction((*tree)->primitives, gl2psFreePrimitive); gl2psListDelete((*tree)->primitives); } if ((*tree)->front) { gl2psFreeBspTree(&(*tree)->front); } gl2psFree(*tree); *tree = NULL; } } static GLboolean gl2psGreater(GLfloat f1, GLfloat f2) { if (f1 > f2) { return GL_TRUE; } else { return GL_FALSE; } } static GLboolean gl2psLess(GLfloat f1, GLfloat f2) { if (f1 < f2) { return GL_TRUE; } else { return GL_FALSE; } } static void gl2psBuildBspTree(GL2PSbsptree* tree, GL2PSlist* primitives) { GL2PSprimitive* prim, *frontprim = NULL, *backprim = NULL; GL2PSlist* frontlist, *backlist; GLint i, index; tree->front = NULL; tree->back = NULL; tree->primitives = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*)); index = gl2psFindRoot(primitives, &prim); gl2psGetPlane(prim, tree->plane); gl2psAddPrimitiveInList(prim, tree->primitives); frontlist = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*)); backlist = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*)); for (i = 0; i < gl2psListNbr(primitives); i++) { if (i != index) { prim = *(GL2PSprimitive**)gl2psListPointer(primitives,i); switch (gl2psSplitPrimitive(prim, tree->plane, &frontprim, &backprim)) { case GL2PS_COINCIDENT: gl2psAddPrimitiveInList(prim, tree->primitives); break; case GL2PS_IN_BACK_OF: gl2psAddPrimitiveInList(prim, backlist); break; case GL2PS_IN_FRONT_OF: gl2psAddPrimitiveInList(prim, frontlist); break; case GL2PS_SPANNING: gl2psAddPrimitiveInList(backprim, backlist); gl2psAddPrimitiveInList(frontprim, frontlist); gl2psFreePrimitive(&prim); break; } } } if (gl2psListNbr(tree->primitives)) { gl2psListSort(tree->primitives, gl2psTrianglesFirst); } if (gl2psListNbr(frontlist)) { gl2psListSort(frontlist, gl2psTrianglesFirst); tree->front = (GL2PSbsptree*)gl2psMalloc(sizeof(GL2PSbsptree)); gl2psBuildBspTree(tree->front, frontlist); } else { gl2psListDelete(frontlist); } if (gl2psListNbr(backlist)) { gl2psListSort(backlist, gl2psTrianglesFirst); tree->back = (GL2PSbsptree*)gl2psMalloc(sizeof(GL2PSbsptree)); gl2psBuildBspTree(tree->back, backlist); } else { gl2psListDelete(backlist); } gl2psListDelete(primitives); } static void gl2psTraverseBspTree(GL2PSbsptree* tree, GL2PSxyz eye, GLfloat epsilon, GLboolean(*compare)(GLfloat f1, GLfloat f2), void (*action)(void* data), int inverse) { GLfloat result; if (!tree) { return; } result = gl2psComparePointPlane(eye, tree->plane); if (GL_TRUE == compare(result, epsilon)) { gl2psTraverseBspTree(tree->back, eye, epsilon, compare, action, inverse); if (inverse) { gl2psListActionInverse(tree->primitives, action); } else { gl2psListAction(tree->primitives, action); } gl2psTraverseBspTree(tree->front, eye, epsilon, compare, action, inverse); } else if (GL_TRUE == compare(-epsilon, result)) { gl2psTraverseBspTree(tree->front, eye, epsilon, compare, action, inverse); if (inverse) { gl2psListActionInverse(tree->primitives, action); } else { gl2psListAction(tree->primitives, action); } gl2psTraverseBspTree(tree->back, eye, epsilon, compare, action, inverse); } else { gl2psTraverseBspTree(tree->front, eye, epsilon, compare, action, inverse); gl2psTraverseBspTree(tree->back, eye, epsilon, compare, action, inverse); } } static void gl2psRescaleAndOffset() { GL2PSprimitive* prim; GLfloat minZ, maxZ, rangeZ, scaleZ; GLfloat factor, units, area, dZ, dZdX, dZdY, maxdZ; int i, j; if (!gl2psListNbr(gl2ps->primitives)) { return; } /* get z-buffer range */ prim = *(GL2PSprimitive**)gl2psListPointer(gl2ps->primitives, 0); minZ = maxZ = prim->verts[0].xyz[2]; for (i = 1; i < prim->numverts; i++) { if (prim->verts[i].xyz[2] < minZ) { minZ = prim->verts[i].xyz[2]; } if (prim->verts[i].xyz[2] > maxZ) { maxZ = prim->verts[i].xyz[2]; } } for (i = 1; i < gl2psListNbr(gl2ps->primitives); i++) { prim = *(GL2PSprimitive**)gl2psListPointer(gl2ps->primitives, i); for (j = 0; j < prim->numverts; j++) { if (prim->verts[j].xyz[2] < minZ) { minZ = prim->verts[j].xyz[2]; } if (prim->verts[j].xyz[2] > maxZ) { maxZ = prim->verts[j].xyz[2]; } } } rangeZ = (maxZ - minZ); /* rescale z-buffer coordinate in [0,GL2PS_ZSCALE], to make it of the same order of magnitude as the x and y coordinates */ scaleZ = GL2PS_ZERO(rangeZ) ? GL2PS_ZSCALE : (GL2PS_ZSCALE / rangeZ); /* avoid precision loss (we use floats!) */ if (scaleZ > 100000.F) { scaleZ = 100000.F; } /* apply offsets */ for (i = 0; i < gl2psListNbr(gl2ps->primitives); i++) { prim = *(GL2PSprimitive**)gl2psListPointer(gl2ps->primitives, i); for (j = 0; j < prim->numverts; j++) { prim->verts[j].xyz[2] = (prim->verts[j].xyz[2] - minZ) * scaleZ; } if ((gl2ps->options & GL2PS_SIMPLE_LINE_OFFSET) && (prim->type == GL2PS_LINE)) { if (gl2ps->sort == GL2PS_SIMPLE_SORT) { prim->verts[0].xyz[2] -= GL2PS_ZOFFSET_LARGE; prim->verts[1].xyz[2] -= GL2PS_ZOFFSET_LARGE; } else { prim->verts[0].xyz[2] -= GL2PS_ZOFFSET; prim->verts[1].xyz[2] -= GL2PS_ZOFFSET; } } else if (prim->offset && (prim->type == GL2PS_TRIANGLE)) { factor = gl2ps->offset[0]; units = gl2ps->offset[1]; area = (prim->verts[1].xyz[0] - prim->verts[0].xyz[0]) * (prim->verts[2].xyz[1] - prim->verts[1].xyz[1]) - (prim->verts[2].xyz[0] - prim->verts[1].xyz[0]) * (prim->verts[1].xyz[1] - prim->verts[0].xyz[1]); if (!GL2PS_ZERO(area)) { dZdX = ((prim->verts[2].xyz[1] - prim->verts[1].xyz[1]) * (prim->verts[1].xyz[2] - prim->verts[0].xyz[2]) - (prim->verts[1].xyz[1] - prim->verts[0].xyz[1]) * (prim->verts[2].xyz[2] - prim->verts[1].xyz[2])) / area; dZdY = ((prim->verts[1].xyz[0] - prim->verts[0].xyz[0]) * (prim->verts[2].xyz[2] - prim->verts[1].xyz[2]) - (prim->verts[2].xyz[0] - prim->verts[1].xyz[0]) * (prim->verts[1].xyz[2] - prim->verts[0].xyz[2])) / area; maxdZ = (GLfloat)sqrt(dZdX * dZdX + dZdY * dZdY); } else { maxdZ = 0.0F; } dZ = factor * maxdZ + units; prim->verts[0].xyz[2] += dZ; prim->verts[1].xyz[2] += dZ; prim->verts[2].xyz[2] += dZ; } } } /********************************************************************* * * 2D sorting routines (for occlusion culling) * *********************************************************************/ static GLint gl2psGetPlaneFromPoints(GL2PSxyz a, GL2PSxyz b, GL2PSplane plane) { GLfloat n; plane[0] = b[1] - a[1]; plane[1] = a[0] - b[0]; n = (GLfloat)sqrt(plane[0]*plane[0] + plane[1]*plane[1]); plane[2] = 0.0F; if (!GL2PS_ZERO(n)) { plane[0] /= n; plane[1] /= n; plane[3] = -plane[0]*a[0]-plane[1]*a[1]; return 1; } else { plane[0] = -1.0F; plane[1] = 0.0F; plane[3] = a[0]; return 0; } } static void gl2psFreeBspImageTree(GL2PSbsptree2d** tree) { if (*tree) { if ((*tree)->back) { gl2psFreeBspImageTree(&(*tree)->back); } if ((*tree)->front) { gl2psFreeBspImageTree(&(*tree)->front); } gl2psFree(*tree); *tree = NULL; } } static GLint gl2psCheckPoint(GL2PSxyz point, GL2PSplane plane) { GLfloat pt_dis; pt_dis = gl2psComparePointPlane(point, plane); if (pt_dis > GL2PS_EPSILON) { return GL2PS_POINT_INFRONT; } else if (pt_dis < -GL2PS_EPSILON) { return GL2PS_POINT_BACK; } else { return GL2PS_POINT_COINCIDENT; } } static void gl2psAddPlanesInBspTreeImage(GL2PSprimitive* prim, GL2PSbsptree2d** tree) { GLint ret = 0; GLint i; GLint offset = 0; GL2PSbsptree2d* head = NULL, *cur = NULL; if ((*tree == NULL) && (prim->numverts > 2)) { /* don't cull if transparent for(i = 0; i < prim->numverts - 1; i++) if(prim->verts[i].rgba[3] < 1.0F) return; */ head = (GL2PSbsptree2d*)gl2psMalloc(sizeof(GL2PSbsptree2d)); for (i = 0; i < prim->numverts-1; i++) { if (!gl2psGetPlaneFromPoints(prim->verts[i].xyz, prim->verts[i+1].xyz, head->plane)) { if (prim->numverts-i > 3) { offset++; } else { gl2psFree(head); return; } } else { break; } } head->back = NULL; head->front = NULL; for (i = 2+offset; i < prim->numverts; i++) { ret = gl2psCheckPoint(prim->verts[i].xyz, head->plane); if (ret != GL2PS_POINT_COINCIDENT) { break; } } switch (ret) { case GL2PS_POINT_INFRONT : cur = head; for (i = 1+offset; i < prim->numverts-1; i++) { if (cur->front == NULL) { cur->front = (GL2PSbsptree2d*)gl2psMalloc(sizeof(GL2PSbsptree2d)); } if (gl2psGetPlaneFromPoints(prim->verts[i].xyz, prim->verts[i+1].xyz, cur->front->plane)) { cur = cur->front; cur->front = NULL; cur->back = NULL; } } if (cur->front == NULL) { cur->front = (GL2PSbsptree2d*)gl2psMalloc(sizeof(GL2PSbsptree2d)); } if (gl2psGetPlaneFromPoints(prim->verts[i].xyz, prim->verts[offset].xyz, cur->front->plane)) { cur->front->front = NULL; cur->front->back = NULL; } else { gl2psFree(cur->front); cur->front = NULL; } break; case GL2PS_POINT_BACK : for (i = 0; i < 4; i++) { head->plane[i] = -head->plane[i]; } cur = head; for (i = 1+offset; i < prim->numverts-1; i++) { if (cur->front == NULL) { cur->front = (GL2PSbsptree2d*)gl2psMalloc(sizeof(GL2PSbsptree2d)); } if (gl2psGetPlaneFromPoints(prim->verts[i+1].xyz, prim->verts[i].xyz, cur->front->plane)) { cur = cur->front; cur->front = NULL; cur->back = NULL; } } if (cur->front == NULL) { cur->front = (GL2PSbsptree2d*)gl2psMalloc(sizeof(GL2PSbsptree2d)); } if (gl2psGetPlaneFromPoints(prim->verts[offset].xyz, prim->verts[i].xyz, cur->front->plane)) { cur->front->front = NULL; cur->front->back = NULL; } else { gl2psFree(cur->front); cur->front = NULL; } break; default: gl2psFree(head); return; } (*tree) = head; } } static GLint gl2psCheckPrimitive(GL2PSprimitive* prim, GL2PSplane plane) { GLint i; GLint pos; pos = gl2psCheckPoint(prim->verts[0].xyz, plane); for (i = 1; i < prim->numverts; i++) { pos |= gl2psCheckPoint(prim->verts[i].xyz, plane); if (pos == (GL2PS_POINT_INFRONT | GL2PS_POINT_BACK)) { return GL2PS_SPANNING; } } if (pos & GL2PS_POINT_INFRONT) { return GL2PS_IN_FRONT_OF; } else if (pos & GL2PS_POINT_BACK) { return GL2PS_IN_BACK_OF; } else { return GL2PS_COINCIDENT; } } static GL2PSprimitive* gl2psCreateSplitPrimitive2D(GL2PSprimitive* parent, GLshort numverts, GL2PSvertex* vertx) { GLint i; GL2PSprimitive* child = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive)); if (parent->type == GL2PS_IMAGEMAP) { child->type = GL2PS_IMAGEMAP; child->data.image = parent->data.image; } else { switch (numverts) { case 1 : child->type = GL2PS_POINT; break; case 2 : child->type = GL2PS_LINE; break; case 3 : child->type = GL2PS_TRIANGLE; break; case 4 : child->type = GL2PS_QUADRANGLE; break; default: child->type = GL2PS_NO_TYPE; break; /* FIXME */ } } child->boundary = 0; /* FIXME: not done! */ child->culled = parent->culled; child->offset = parent->offset; child->pattern = parent->pattern; child->factor = parent->factor; child->width = parent->width; child->numverts = numverts; child->verts = (GL2PSvertex*)gl2psMalloc(numverts * sizeof(GL2PSvertex)); for (i = 0; i < numverts; i++) { child->verts[i] = vertx[i]; } return child; } static void gl2psSplitPrimitive2D(GL2PSprimitive* prim, GL2PSplane plane, GL2PSprimitive** front, GL2PSprimitive** back) { /* cur will hold the position of the current vertex prev will hold the position of the previous vertex prev0 will hold the position of the vertex number 0 v1 and v2 represent the current and previous vertices, respectively flag is set if the current vertex should be checked against the plane */ GLint cur = -1, prev = -1, i, v1 = 0, v2 = 0, flag = 1, prev0 = -1; /* list of vertices that will go in front and back primitive */ GL2PSvertex* front_list = NULL, *back_list = NULL; /* number of vertices in front and back list */ GLshort front_count = 0, back_count = 0; for (i = 0; i <= prim->numverts; i++) { v1 = i; if (v1 == prim->numverts) { if (prim->numverts < 3) { break; } v1 = 0; v2 = prim->numverts - 1; cur = prev0; } else if (flag) { cur = gl2psCheckPoint(prim->verts[v1].xyz, plane); if (i == 0) { prev0 = cur; } } if (((prev == -1) || (prev == cur) || (prev == 0) || (cur == 0)) && (i < prim->numverts)) { if (cur == GL2PS_POINT_INFRONT) { front_count++; front_list = (GL2PSvertex*)gl2psRealloc(front_list, sizeof(GL2PSvertex)*front_count); front_list[front_count-1] = prim->verts[v1]; } else if (cur == GL2PS_POINT_BACK) { back_count++; back_list = (GL2PSvertex*)gl2psRealloc(back_list, sizeof(GL2PSvertex)*back_count); back_list[back_count-1] = prim->verts[v1]; } else { front_count++; front_list = (GL2PSvertex*)gl2psRealloc(front_list, sizeof(GL2PSvertex)*front_count); front_list[front_count-1] = prim->verts[v1]; back_count++; back_list = (GL2PSvertex*)gl2psRealloc(back_list, sizeof(GL2PSvertex)*back_count); back_list[back_count-1] = prim->verts[v1]; } flag = 1; } else if ((prev != cur) && (cur != 0) && (prev != 0)) { if (v1 != 0) { v2 = v1-1; i--; } front_count++; front_list = (GL2PSvertex*)gl2psRealloc(front_list, sizeof(GL2PSvertex)*front_count); gl2psCutEdge(&prim->verts[v2], &prim->verts[v1], plane, &front_list[front_count-1]); back_count++; back_list = (GL2PSvertex*)gl2psRealloc(back_list, sizeof(GL2PSvertex)*back_count); back_list[back_count-1] = front_list[front_count-1]; flag = 0; } prev = cur; } *front = gl2psCreateSplitPrimitive2D(prim, front_count, front_list); *back = gl2psCreateSplitPrimitive2D(prim, back_count, back_list); gl2psFree(front_list); gl2psFree(back_list); } static GLint gl2psAddInBspImageTree(GL2PSprimitive* prim, GL2PSbsptree2d** tree) { GLint ret = 0; GL2PSprimitive* frontprim = NULL, *backprim = NULL; /* FIXME: until we consider the actual extent of text strings and pixmaps, never cull them. Otherwise the whole string/pixmap gets culled as soon as the reference point is hidden */ if (prim->type == GL2PS_PIXMAP || prim->type == GL2PS_TEXT || prim->type == GL2PS_SPECIAL) { return 1; } if (*tree == NULL) { if ((prim->type != GL2PS_IMAGEMAP) && (GL_FALSE == gl2ps->zerosurfacearea)) { gl2psAddPlanesInBspTreeImage(gl2ps->primitivetoadd, tree); } return 1; } else { switch (gl2psCheckPrimitive(prim, (*tree)->plane)) { case GL2PS_IN_BACK_OF: return gl2psAddInBspImageTree(prim, &(*tree)->back); case GL2PS_IN_FRONT_OF: if ((*tree)->front != NULL) { return gl2psAddInBspImageTree(prim, &(*tree)->front); } else { return 0; } case GL2PS_SPANNING: gl2psSplitPrimitive2D(prim, (*tree)->plane, &frontprim, &backprim); ret = gl2psAddInBspImageTree(backprim, &(*tree)->back); if ((*tree)->front != NULL) { if (gl2psAddInBspImageTree(frontprim, &(*tree)->front)) { ret = 1; } } gl2psFree(frontprim->verts); gl2psFree(frontprim); gl2psFree(backprim->verts); gl2psFree(backprim); return ret; case GL2PS_COINCIDENT: if ((*tree)->back != NULL) { gl2ps->zerosurfacearea = GL_TRUE; ret = gl2psAddInBspImageTree(prim, &(*tree)->back); gl2ps->zerosurfacearea = GL_FALSE; if (ret) { return ret; } } if ((*tree)->front != NULL) { gl2ps->zerosurfacearea = GL_TRUE; ret = gl2psAddInBspImageTree(prim, &(*tree)->front); gl2ps->zerosurfacearea = GL_FALSE; if (ret) { return ret; } } if (prim->type == GL2PS_LINE) { return 1; } else { return 0; } } } return 0; } static void gl2psAddInImageTree(void* data) { GL2PSprimitive* prim = *(GL2PSprimitive**)data; gl2ps->primitivetoadd = prim; if (prim->type == GL2PS_IMAGEMAP && prim->data.image->format == GL2PS_IMAGEMAP_VISIBLE) { prim->culled = 1; } else if (!gl2psAddInBspImageTree(prim, &gl2ps->imagetree)) { prim->culled = 1; } else if (prim->type == GL2PS_IMAGEMAP) { prim->data.image->format = GL2PS_IMAGEMAP_VISIBLE; } } /* Boundary construction */ static void gl2psAddBoundaryInList(GL2PSprimitive* prim, GL2PSlist* list) { GL2PSprimitive* b; GLshort i; GL2PSxyz c; c[0] = c[1] = c[2] = 0.0F; for (i = 0; i < prim->numverts; i++) { c[0] += prim->verts[i].xyz[0]; c[1] += prim->verts[i].xyz[1]; } c[0] /= prim->numverts; c[1] /= prim->numverts; for (i = 0; i < prim->numverts; i++) { if (prim->boundary & (GLint)pow(2., i)) { b = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive)); b->type = GL2PS_LINE; b->offset = prim->offset; b->pattern = prim->pattern; b->factor = prim->factor; b->culled = prim->culled; b->width = prim->width; b->boundary = 0; b->numverts = 2; b->verts = (GL2PSvertex*)gl2psMalloc(2 * sizeof(GL2PSvertex)); #if 0 /* FIXME: need to work on boundary offset... */ v[0] = c[0] - prim->verts[i].xyz[0]; v[1] = c[1] - prim->verts[i].xyz[1]; v[2] = 0.0F; norm = gl2psNorm(v); v[0] /= norm; v[1] /= norm; b->verts[0].xyz[0] = prim->verts[i].xyz[0] +0.1*v[0]; b->verts[0].xyz[1] = prim->verts[i].xyz[1] +0.1*v[1]; b->verts[0].xyz[2] = prim->verts[i].xyz[2]; v[0] = c[0] - prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[0]; v[1] = c[1] - prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[1]; norm = gl2psNorm(v); v[0] /= norm; v[1] /= norm; b->verts[1].xyz[0] = prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[0] +0.1*v[0]; b->verts[1].xyz[1] = prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[1] +0.1*v[1]; b->verts[1].xyz[2] = prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[2]; #else b->verts[0].xyz[0] = prim->verts[i].xyz[0]; b->verts[0].xyz[1] = prim->verts[i].xyz[1]; b->verts[0].xyz[2] = prim->verts[i].xyz[2]; b->verts[1].xyz[0] = prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[0]; b->verts[1].xyz[1] = prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[1]; b->verts[1].xyz[2] = prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[2]; #endif b->verts[0].rgba[0] = 0.0F; b->verts[0].rgba[1] = 0.0F; b->verts[0].rgba[2] = 0.0F; b->verts[0].rgba[3] = 0.0F; b->verts[1].rgba[0] = 0.0F; b->verts[1].rgba[1] = 0.0F; b->verts[1].rgba[2] = 0.0F; b->verts[1].rgba[3] = 0.0F; gl2psListAdd(list, &b); } } } static void gl2psBuildPolygonBoundary(GL2PSbsptree* tree) { GLint i; GL2PSprimitive* prim; if (!tree) { return; } gl2psBuildPolygonBoundary(tree->back); for (i = 0; i < gl2psListNbr(tree->primitives); i++) { prim = *(GL2PSprimitive**)gl2psListPointer(tree->primitives, i); if (prim->boundary) { gl2psAddBoundaryInList(prim, tree->primitives); } } gl2psBuildPolygonBoundary(tree->front); } /********************************************************************* * * Feedback buffer parser * *********************************************************************/ static void gl2psAddPolyPrimitive(GLshort type, GLshort numverts, GL2PSvertex* verts, GLint offset, GLushort pattern, GLint factor, GLfloat width, char boundary) { GL2PSprimitive* prim; prim = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive)); prim->type = type; prim->numverts = numverts; prim->verts = (GL2PSvertex*)gl2psMalloc(numverts * sizeof(GL2PSvertex)); memcpy(prim->verts, verts, numverts * sizeof(GL2PSvertex)); prim->boundary = boundary; prim->offset = offset; prim->pattern = pattern; prim->factor = factor; prim->width = width; prim->culled = 0; /* FIXME: here we should have an option to split stretched tris/quads to enhance SIMPLE_SORT */ gl2psListAdd(gl2ps->primitives, &prim); } static GLint gl2psGetVertex(GL2PSvertex* v, GLfloat* p) { GLint i; v->xyz[0] = p[0]; v->xyz[1] = p[1]; v->xyz[2] = p[2]; if (gl2ps->colormode == GL_COLOR_INDEX && gl2ps->colorsize > 0) { i = (GLint)(p[3] + 0.5); v->rgba[0] = gl2ps->colormap[i][0]; v->rgba[1] = gl2ps->colormap[i][1]; v->rgba[2] = gl2ps->colormap[i][2]; v->rgba[3] = gl2ps->colormap[i][3]; return 4; } else { v->rgba[0] = p[3]; v->rgba[1] = p[4]; v->rgba[2] = p[5]; v->rgba[3] = p[6]; return 7; } } static void gl2psParseFeedbackBuffer(GLint used) { char flag; GLushort pattern = 0; GLboolean boundary; GLint i, sizeoffloat, count, v, vtot, offset = 0, factor = 0, auxindex = 0; GLfloat lwidth = 1.0F, psize = 1.0F; GLfloat* current; GL2PSvertex vertices[3]; GL2PSprimitive* prim; GL2PSimagemap* node; current = gl2ps->feedback; boundary = gl2ps->boundary = GL_FALSE; while (used > 0) { if (GL_TRUE == boundary) { gl2ps->boundary = GL_TRUE; } switch ((GLint)*current) { case GL_POINT_TOKEN : current ++; used --; i = gl2psGetVertex(&vertices[0], current); current += i; used -= i; gl2psAddPolyPrimitive(GL2PS_POINT, 1, vertices, 0, pattern, factor, psize, 0); break; case GL_LINE_TOKEN : case GL_LINE_RESET_TOKEN : current ++; used --; i = gl2psGetVertex(&vertices[0], current); current += i; used -= i; i = gl2psGetVertex(&vertices[1], current); current += i; used -= i; gl2psAddPolyPrimitive(GL2PS_LINE, 2, vertices, 0, pattern, factor, lwidth, 0); break; case GL_POLYGON_TOKEN : count = (GLint)current[1]; current += 2; used -= 2; v = vtot = 0; while (count > 0 && used > 0) { i = gl2psGetVertex(&vertices[v], current); gl2psAdaptVertexForBlending(&vertices[v]); current += i; used -= i; count --; vtot++; if (v == 2) { if (GL_TRUE == boundary) { if (!count && vtot == 2) { flag = 1|2|4; } else if (!count) { flag = 2|4; } else if (vtot == 2) { flag = 1|2; } else { flag = 2; } } else { flag = 0; } gl2psAddPolyPrimitive(GL2PS_TRIANGLE, 3, vertices, offset, pattern, factor, 1, flag); vertices[1] = vertices[2]; } else { v ++; } } break; case GL_BITMAP_TOKEN : case GL_DRAW_PIXEL_TOKEN : case GL_COPY_PIXEL_TOKEN : current ++; used --; i = gl2psGetVertex(&vertices[0], current); current += i; used -= i; break; case GL_PASS_THROUGH_TOKEN : switch ((GLint)current[1]) { case GL2PS_BEGIN_OFFSET_TOKEN : offset = 1; break; case GL2PS_END_OFFSET_TOKEN : offset = 0; break; case GL2PS_BEGIN_BOUNDARY_TOKEN : boundary = GL_TRUE; break; case GL2PS_END_BOUNDARY_TOKEN : boundary = GL_FALSE; break; case GL2PS_END_STIPPLE_TOKEN : pattern = factor = 0; break; case GL2PS_BEGIN_BLEND_TOKEN : gl2ps->blending = GL_TRUE; break; case GL2PS_END_BLEND_TOKEN : gl2ps->blending = GL_FALSE; break; case GL2PS_BEGIN_STIPPLE_TOKEN : current += 2; used -= 2; pattern = (GLushort)current[1]; current += 2; used -= 2; factor = (GLint)current[1]; break; case GL2PS_SRC_BLEND_TOKEN : current += 2; used -= 2; gl2ps->blendfunc[0] = (GLint)current[1]; break; case GL2PS_DST_BLEND_TOKEN : current += 2; used -= 2; gl2ps->blendfunc[1] = (GLint)current[1]; break; case GL2PS_POINT_SIZE_TOKEN : current += 2; used -= 2; psize = current[1]; break; case GL2PS_LINE_WIDTH_TOKEN : current += 2; used -= 2; lwidth = current[1]; break; case GL2PS_IMAGEMAP_TOKEN : prim = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive)); prim->type = GL2PS_IMAGEMAP; prim->boundary = 0; prim->numverts = 4; prim->verts = (GL2PSvertex*)gl2psMalloc(4 * sizeof(GL2PSvertex)); prim->culled = 0; prim->offset = 0; prim->pattern = 0; prim->factor = 0; prim->width = 1; node = (GL2PSimagemap*)gl2psMalloc(sizeof(GL2PSimagemap)); node->image = (GL2PSimage*)gl2psMalloc(sizeof(GL2PSimage)); node->image->type = 0; node->image->format = 0; node->next = NULL; if (gl2ps->imagemap_head == NULL) { gl2ps->imagemap_head = node; } else { gl2ps->imagemap_tail->next = node; } gl2ps->imagemap_tail = node; prim->data.image = node->image; current += 2; used -= 2; i = gl2psGetVertex(&prim->verts[0], ¤t[1]); current += i; used -= i; node->image->width = (GLint)current[2]; current += 2; used -= 2; node->image->height = (GLint)current[2]; prim->verts[0].xyz[0] = prim->verts[0].xyz[0] - (int)(node->image->width / 2) + 0.5F; prim->verts[0].xyz[1] = prim->verts[0].xyz[1] - (int)(node->image->height / 2) + 0.5F; for (i = 1; i < 4; i++) { for (v = 0; v < 3; v++) { prim->verts[i].xyz[v] = prim->verts[0].xyz[v]; prim->verts[i].rgba[v] = prim->verts[0].rgba[v]; } prim->verts[i].rgba[v] = prim->verts[0].rgba[v]; } prim->verts[1].xyz[0] = prim->verts[1].xyz[0] + node->image->width; prim->verts[2].xyz[0] = prim->verts[1].xyz[0]; prim->verts[2].xyz[1] = prim->verts[2].xyz[1] + node->image->height; prim->verts[3].xyz[1] = prim->verts[2].xyz[1]; sizeoffloat = sizeof(GLfloat); v = 2 * sizeoffloat; vtot = node->image->height + node->image->height * ((node->image->width - 1) / 8); node->image->pixels = (GLfloat*)gl2psMalloc(v + vtot); node->image->pixels[0] = prim->verts[0].xyz[0]; node->image->pixels[1] = prim->verts[0].xyz[1]; for (i = 0; i < vtot; i += sizeoffloat) { current += 2; used -= 2; if ((vtot - i) >= 4) { memcpy(&(((char*)(node->image->pixels))[i + v]), &(current[2]), sizeoffloat); } else { memcpy(&(((char*)(node->image->pixels))[i + v]), &(current[2]), vtot - i); } } current++; used--; gl2psListAdd(gl2ps->primitives, &prim); break; case GL2PS_DRAW_PIXELS_TOKEN : case GL2PS_TEXT_TOKEN : if (auxindex < gl2psListNbr(gl2ps->auxprimitives)) gl2psListAdd(gl2ps->primitives, gl2psListPointer(gl2ps->auxprimitives, auxindex++)); else { gl2psMsg(GL2PS_ERROR, "Wrong number of auxiliary tokens in buffer"); } break; } current += 2; used -= 2; break; default : gl2psMsg(GL2PS_WARNING, "Unknown token in buffer"); current ++; used --; break; } } gl2psListReset(gl2ps->auxprimitives); } /********************************************************************* * * PostScript routines * *********************************************************************/ static void gl2psWriteByte(unsigned char byte) { unsigned char h = byte / 16; unsigned char l = byte % 16; gl2psPrintf("%x%x", h, l); } static void gl2psPrintPostScriptPixmap(GLfloat x, GLfloat y, GL2PSimage* im) { GLuint nbhex, nbyte, nrgb, nbits; GLuint row, col, ibyte, icase; GLfloat dr, dg, db, fgrey; unsigned char red = 0, green = 0, blue = 0, b, grey; GLuint width = (GLuint)im->width; GLuint height = (GLuint)im->height; /* FIXME: should we define an option for these? Or just keep the 8-bit per component case? */ int greyscale = 0; /* set to 1 to output greyscale image */ int nbit = 8; /* number of bits per color compoment (2, 4 or 8) */ if ((width <= 0) || (height <= 0)) { return; } gl2psPrintf("gsave\n"); gl2psPrintf("%.2f %.2f translate\n", x, y); gl2psPrintf("%d %d scale\n", width, height); if (greyscale) /* greyscale */ { gl2psPrintf("/picstr %d string def\n", width); gl2psPrintf("%d %d %d\n", width, height, 8); gl2psPrintf("[ %d 0 0 -%d 0 %d ]\n", width, height, height); gl2psPrintf("{ currentfile picstr readhexstring pop }\n"); gl2psPrintf("image\n"); for (row = 0; row < height; row++) { for (col = 0; col < width; col++) { gl2psGetRGB(im, col, row, &dr, &dg, &db); fgrey = (0.30F * dr + 0.59F * dg + 0.11F * db); grey = (unsigned char)(255. * fgrey); gl2psWriteByte(grey); } gl2psPrintf("\n"); } nbhex = width * height * 2; gl2psPrintf("%%%% nbhex digit :%d\n", nbhex); } else if (nbit == 2) /* color, 2 bits for r and g and b; rgbs following each other */ { nrgb = width * 3; nbits = nrgb * nbit; nbyte = nbits / 8; if ((nbyte * 8) != nbits) { nbyte++; } gl2psPrintf("/rgbstr %d string def\n", nbyte); gl2psPrintf("%d %d %d\n", width, height, nbit); gl2psPrintf("[ %d 0 0 -%d 0 %d ]\n", width, height, height); gl2psPrintf("{ currentfile rgbstr readhexstring pop }\n"); gl2psPrintf("false 3\n"); gl2psPrintf("colorimage\n"); for (row = 0; row < height; row++) { icase = 1; col = 0; b = 0; for (ibyte = 0; ibyte < nbyte; ibyte++) { if (icase == 1) { if (col < width) { gl2psGetRGB(im, col, row, &dr, &dg, &db); } else { dr = dg = db = 0; } col++; red = (unsigned char)(3. * dr); green = (unsigned char)(3. * dg); blue = (unsigned char)(3. * db); b = red; b = (b<<2) + green; b = (b<<2) + blue; if (col < width) { gl2psGetRGB(im, col, row, &dr, &dg, &db); } else { dr = dg = db = 0; } col++; red = (unsigned char)(3. * dr); green = (unsigned char)(3. * dg); blue = (unsigned char)(3. * db); b = (b<<2) + red; gl2psWriteByte(b); b = 0; icase++; } else if (icase == 2) { b = green; b = (b<<2) + blue; if (col < width) { gl2psGetRGB(im, col, row, &dr, &dg, &db); } else { dr = dg = db = 0; } col++; red = (unsigned char)(3. * dr); green = (unsigned char)(3. * dg); blue = (unsigned char)(3. * db); b = (b<<2) + red; b = (b<<2) + green; gl2psWriteByte(b); b = 0; icase++; } else if (icase == 3) { b = blue; if (col < width) { gl2psGetRGB(im, col, row, &dr, &dg, &db); } else { dr = dg = db = 0; } col++; red = (unsigned char)(3. * dr); green = (unsigned char)(3. * dg); blue = (unsigned char)(3. * db); b = (b<<2) + red; b = (b<<2) + green; b = (b<<2) + blue; gl2psWriteByte(b); b = 0; icase = 1; } } gl2psPrintf("\n"); } } else if (nbit == 4) /* color, 4 bits for r and g and b; rgbs following each other */ { nrgb = width * 3; nbits = nrgb * nbit; nbyte = nbits / 8; if ((nbyte * 8) != nbits) { nbyte++; } gl2psPrintf("/rgbstr %d string def\n", nbyte); gl2psPrintf("%d %d %d\n", width, height, nbit); gl2psPrintf("[ %d 0 0 -%d 0 %d ]\n", width, height, height); gl2psPrintf("{ currentfile rgbstr readhexstring pop }\n"); gl2psPrintf("false 3\n"); gl2psPrintf("colorimage\n"); for (row = 0; row < height; row++) { col = 0; icase = 1; for (ibyte = 0; ibyte < nbyte; ibyte++) { if (icase == 1) { if (col < width) { gl2psGetRGB(im, col, row, &dr, &dg, &db); } else { dr = dg = db = 0; } col++; red = (unsigned char)(15. * dr); green = (unsigned char)(15. * dg); gl2psPrintf("%x%x", red, green); icase++; } else if (icase == 2) { blue = (unsigned char)(15. * db); if (col < width) { gl2psGetRGB(im, col, row, &dr, &dg, &db); } else { dr = dg = db = 0; } col++; red = (unsigned char)(15. * dr); gl2psPrintf("%x%x", blue, red); icase++; } else if (icase == 3) { green = (unsigned char)(15. * dg); blue = (unsigned char)(15. * db); gl2psPrintf("%x%x", green, blue); icase = 1; } } gl2psPrintf("\n"); } } else /* 8 bit for r and g and b */ { nbyte = width * 3; gl2psPrintf("/rgbstr %d string def\n", nbyte); gl2psPrintf("%d %d %d\n", width, height, 8); gl2psPrintf("[ %d 0 0 -%d 0 %d ]\n", width, height, height); gl2psPrintf("{ currentfile rgbstr readhexstring pop }\n"); gl2psPrintf("false 3\n"); gl2psPrintf("colorimage\n"); for (row = 0; row < height; row++) { for (col = 0; col < width; col++) { gl2psGetRGB(im, col, row, &dr, &dg, &db); red = (unsigned char)(255. * dr); gl2psWriteByte(red); green = (unsigned char)(255. * dg); gl2psWriteByte(green); blue = (unsigned char)(255. * db); gl2psWriteByte(blue); } gl2psPrintf("\n"); } } gl2psPrintf("grestore\n"); } static void gl2psPrintPostScriptImagemap(GLfloat x, GLfloat y, GLsizei width, GLsizei height, const unsigned char* imagemap) { int i, size; if ((width <= 0) || (height <= 0)) { return; } size = height + height * (width - 1) / 8; gl2psPrintf("gsave\n"); gl2psPrintf("%.2f %.2f translate\n", x, y); gl2psPrintf("%d %d scale\n%d %d\ntrue\n", width, height,width, height); gl2psPrintf("[ %d 0 0 -%d 0 %d ] {<", width, height); for (i = 0; i < size; i++) { gl2psWriteByte(*imagemap); imagemap++; } gl2psPrintf(">} imagemask\ngrestore\n"); } static void gl2psPrintPostScriptHeader(void) { time_t now; /* Since compression is not part of the PostScript standard, compressed PostScript files are just gzipped PostScript files ("ps.gz" or "eps.gz") */ gl2psPrintGzipHeader(); time(&now); if (gl2ps->format == GL2PS_PS) { gl2psPrintf("%%!PS-Adobe-3.0\n"); } else { gl2psPrintf("%%!PS-Adobe-3.0 EPSF-3.0\n"); } gl2psPrintf("%%%%Title: %s\n" "%%%%Creator: GL2PS %d.%d.%d%s, %s\n" "%%%%For: %s\n" "%%%%CreationDate: %s" "%%%%LanguageLevel: 3\n" "%%%%DocumentData: Clean7Bit\n" "%%%%Pages: 1\n", gl2ps->title, GL2PS_MAJOR_VERSION, GL2PS_MINOR_VERSION, GL2PS_PATCH_VERSION, GL2PS_EXTRA_VERSION, GL2PS_COPYRIGHT, gl2ps->producer, ctime(&now)); if (gl2ps->format == GL2PS_PS) { gl2psPrintf("%%%%Orientation: %s\n" "%%%%DocumentMedia: Default %d %d 0 () ()\n", (gl2ps->options & GL2PS_LANDSCAPE) ? "Landscape" : "Portrait", (gl2ps->options & GL2PS_LANDSCAPE) ? (int)gl2ps->viewport[3] : (int)gl2ps->viewport[2], (gl2ps->options & GL2PS_LANDSCAPE) ? (int)gl2ps->viewport[2] : (int)gl2ps->viewport[3]); } gl2psPrintf("%%%%BoundingBox: %d %d %d %d\n" "%%%%EndComments\n", (gl2ps->options & GL2PS_LANDSCAPE) ? (int)gl2ps->viewport[1] : (int)gl2ps->viewport[0], (gl2ps->options & GL2PS_LANDSCAPE) ? (int)gl2ps->viewport[0] : (int)gl2ps->viewport[1], (gl2ps->options & GL2PS_LANDSCAPE) ? (int)gl2ps->viewport[3] : (int)gl2ps->viewport[2], (gl2ps->options & GL2PS_LANDSCAPE) ? (int)gl2ps->viewport[2] : (int)gl2ps->viewport[3]); /* RGB color: r g b C (replace C by G in output to change from rgb to gray) Grayscale: r g b G Font choose: size fontname FC Text string: (string) x y size fontname S?? Rotated text string: (string) angle x y size fontname S??R Point primitive: x y size P Line width: width W Line start: x y LS Line joining last point: x y L Line end: x y LE Flat-shaded triangle: x3 y3 x2 y2 x1 y1 T Smooth-shaded triangle: x3 y3 r3 g3 b3 x2 y2 r2 g2 b2 x1 y1 r1 g1 b1 ST */ gl2psPrintf("%%%%BeginProlog\n" "/gl2psdict 64 dict def gl2psdict begin\n" "0 setlinecap 0 setlinejoin\n" "/tryPS3shading %s def %% set to false to force subdivision\n" "/rThreshold %g def %% red component subdivision threshold\n" "/gThreshold %g def %% green component subdivision threshold\n" "/bThreshold %g def %% blue component subdivision threshold\n", (gl2ps->options & GL2PS_NO_PS3_SHADING) ? "false" : "true", gl2ps->threshold[0], gl2ps->threshold[1], gl2ps->threshold[2]); gl2psPrintf("/BD { bind def } bind def\n" "/C { setrgbcolor } BD\n" "/G { 0.082 mul exch 0.6094 mul add exch 0.3086 mul add neg 1.0 add setgray } BD\n" "/W { setlinewidth } BD\n"); gl2psPrintf("/FC { findfont exch /SH exch def SH scalefont setfont } BD\n" "/SW { dup stringwidth pop } BD\n" "/S { FC moveto show } BD\n" "/SBC{ FC moveto SW -2 div 0 rmoveto show } BD\n" "/SBR{ FC moveto SW neg 0 rmoveto show } BD\n" "/SCL{ FC moveto 0 SH -2 div rmoveto show } BD\n" "/SCC{ FC moveto SW -2 div SH -2 div rmoveto show } BD\n" "/SCR{ FC moveto SW neg SH -2 div rmoveto show } BD\n" "/STL{ FC moveto 0 SH neg rmoveto show } BD\n" "/STC{ FC moveto SW -2 div SH neg rmoveto show } BD\n" "/STR{ FC moveto SW neg SH neg rmoveto show } BD\n"); /* rotated text routines: same nameanem with R appended */ gl2psPrintf("/FCT { FC translate 0 0 } BD\n" "/SR { gsave FCT moveto rotate show grestore } BD\n" "/SBCR{ gsave FCT moveto rotate SW -2 div 0 rmoveto show grestore } BD\n" "/SBRR{ gsave FCT moveto rotate SW neg 0 rmoveto show grestore } BD\n" "/SCLR{ gsave FCT moveto rotate 0 SH -2 div rmoveto show grestore} BD\n"); gl2psPrintf("/SCCR{ gsave FCT moveto rotate SW -2 div SH -2 div rmoveto show grestore} BD\n" "/SCRR{ gsave FCT moveto rotate SW neg SH -2 div rmoveto show grestore} BD\n" "/STLR{ gsave FCT moveto rotate 0 SH neg rmoveto show grestore } BD\n" "/STCR{ gsave FCT moveto rotate SW -2 div SH neg rmoveto show grestore } BD\n" "/STRR{ gsave FCT moveto rotate SW neg SH neg rmoveto show grestore } BD\n"); gl2psPrintf("/P { newpath 0.0 360.0 arc closepath fill } BD\n" "/LS { newpath moveto } BD\n" "/L { lineto } BD\n" "/LE { lineto stroke } BD\n" "/T { newpath moveto lineto lineto closepath fill } BD\n"); /* Smooth-shaded triangle with PostScript level 3 shfill operator: x3 y3 r3 g3 b3 x2 y2 r2 g2 b2 x1 y1 r1 g1 b1 STshfill */ gl2psPrintf("/STshfill {\n" " /b1 exch def /g1 exch def /r1 exch def /y1 exch def /x1 exch def\n" " /b2 exch def /g2 exch def /r2 exch def /y2 exch def /x2 exch def\n" " /b3 exch def /g3 exch def /r3 exch def /y3 exch def /x3 exch def\n" " gsave << /ShadingType 4 /ColorSpace [/DeviceRGB]\n" " /DataSource [ 0 x1 y1 r1 g1 b1 0 x2 y2 r2 g2 b2 0 x3 y3 r3 g3 b3 ] >>\n" " shfill grestore } BD\n"); /* Flat-shaded triangle with middle color: x3 y3 r3 g3 b3 x2 y2 r2 g2 b2 x1 y1 r1 g1 b1 Tm */ gl2psPrintf(/* stack : x3 y3 r3 g3 b3 x2 y2 r2 g2 b2 x1 y1 r1 g1 b1 */ "/Tm { 3 -1 roll 8 -1 roll 13 -1 roll add add 3 div\n" /* r = (r1+r2+r3)/3 */ /* stack : x3 y3 g3 b3 x2 y2 g2 b2 x1 y1 g1 b1 r */ " 3 -1 roll 7 -1 roll 11 -1 roll add add 3 div\n" /* g = (g1+g2+g3)/3 */ /* stack : x3 y3 b3 x2 y2 b2 x1 y1 b1 r g b */ " 3 -1 roll 6 -1 roll 9 -1 roll add add 3 div" /* b = (b1+b2+b3)/3 */ /* stack : x3 y3 x2 y2 x1 y1 r g b */ " C T } BD\n"); /* Split triangle in four sub-triangles (at sides middle points) and call the STnoshfill procedure on each, interpolating the colors in RGB space: x3 y3 r3 g3 b3 x2 y2 r2 g2 b2 x1 y1 r1 g1 b1 STsplit (in procedure comments key: (Vi) = xi yi ri gi bi) */ gl2psPrintf("/STsplit {\n" " 4 index 15 index add 0.5 mul\n" /* x13 = (x1+x3)/2 */ " 4 index 15 index add 0.5 mul\n" /* y13 = (y1+y3)/2 */ " 4 index 15 index add 0.5 mul\n" /* r13 = (r1+r3)/2 */ " 4 index 15 index add 0.5 mul\n" /* g13 = (g1+g3)/2 */ " 4 index 15 index add 0.5 mul\n" /* b13 = (b1+b3)/2 */ " 5 copy 5 copy 25 15 roll\n"); /* at his point, stack = (V3) (V13) (V13) (V13) (V2) (V1) */ gl2psPrintf(" 9 index 30 index add 0.5 mul\n" /* x23 = (x2+x3)/2 */ " 9 index 30 index add 0.5 mul\n" /* y23 = (y2+y3)/2 */ " 9 index 30 index add 0.5 mul\n" /* r23 = (r2+r3)/2 */ " 9 index 30 index add 0.5 mul\n" /* g23 = (g2+g3)/2 */ " 9 index 30 index add 0.5 mul\n" /* b23 = (b2+b3)/2 */ " 5 copy 5 copy 35 5 roll 25 5 roll 15 5 roll\n"); /* stack = (V3) (V13) (V23) (V13) (V23) (V13) (V23) (V2) (V1) */ gl2psPrintf(" 4 index 10 index add 0.5 mul\n" /* x12 = (x1+x2)/2 */ " 4 index 10 index add 0.5 mul\n" /* y12 = (y1+y2)/2 */ " 4 index 10 index add 0.5 mul\n" /* r12 = (r1+r2)/2 */ " 4 index 10 index add 0.5 mul\n" /* g12 = (g1+g2)/2 */ " 4 index 10 index add 0.5 mul\n" /* b12 = (b1+b2)/2 */ " 5 copy 5 copy 40 5 roll 25 5 roll 15 5 roll 25 5 roll\n"); /* stack = (V3) (V13) (V23) (V13) (V12) (V23) (V13) (V1) (V12) (V23) (V12) (V2) */ gl2psPrintf(" STnoshfill STnoshfill STnoshfill STnoshfill } BD\n"); /* Gouraud shaded triangle using recursive subdivision until the difference between corner colors does not exceed the thresholds: x3 y3 r3 g3 b3 x2 y2 r2 g2 b2 x1 y1 r1 g1 b1 STnoshfill */ gl2psPrintf("/STnoshfill {\n" " 2 index 8 index sub abs rThreshold gt\n" /* |r1-r2|>rth */ " { STsplit }\n" " { 1 index 7 index sub abs gThreshold gt\n" /* |g1-g2|>gth */ " { STsplit }\n" " { dup 6 index sub abs bThreshold gt\n" /* |b1-b2|>bth */ " { STsplit }\n" " { 2 index 13 index sub abs rThreshold gt\n" /* |r1-r3|>rht */ " { STsplit }\n" " { 1 index 12 index sub abs gThreshold gt\n" /* |g1-g3|>gth */ " { STsplit }\n" " { dup 11 index sub abs bThreshold gt\n" /* |b1-b3|>bth */ " { STsplit }\n" " { 7 index 13 index sub abs rThreshold gt\n"); /* |r2-r3|>rht */ gl2psPrintf(" { STsplit }\n" " { 6 index 12 index sub abs gThreshold gt\n" /* |g2-g3|>gth */ " { STsplit }\n" " { 5 index 11 index sub abs bThreshold gt\n" /* |b2-b3|>bth */ " { STsplit }\n" " { Tm }\n" /* all colors sufficiently similar */ " ifelse }\n" " ifelse }\n" " ifelse }\n" " ifelse }\n" " ifelse }\n" " ifelse }\n" " ifelse }\n" " ifelse }\n" " ifelse } BD\n"); gl2psPrintf("tryPS3shading\n" "{ /shfill where\n" " { /ST { STshfill } BD }\n" " { /ST { STnoshfill } BD }\n" " ifelse }\n" "{ /ST { STnoshfill } BD }\n" "ifelse\n"); gl2psPrintf("end\n" "%%%%EndProlog\n" "%%%%BeginSetup\n" "/DeviceRGB setcolorspace\n" "gl2psdict begin\n" "%%%%EndSetup\n" "%%%%Page: 1 1\n" "%%%%BeginPageSetup\n"); if (gl2ps->options & GL2PS_LANDSCAPE) { gl2psPrintf("%d 0 translate 90 rotate\n", (int)gl2ps->viewport[3]); } gl2psPrintf("%%%%EndPageSetup\n" "mark\n" "gsave\n" "1.0 1.0 scale\n"); if (gl2ps->options & GL2PS_DRAW_BACKGROUND) { gl2psPrintf("%g %g %g C\n" "newpath %d %d moveto %d %d lineto %d %d lineto %d %d lineto\n" "closepath fill\n", gl2ps->bgcolor[0], gl2ps->bgcolor[1], gl2ps->bgcolor[2], (int)gl2ps->viewport[0], (int)gl2ps->viewport[1], (int)gl2ps->viewport[2], (int)gl2ps->viewport[1], (int)gl2ps->viewport[2], (int)gl2ps->viewport[3], (int)gl2ps->viewport[0], (int)gl2ps->viewport[3]); } } static void gl2psPrintPostScriptColor(GL2PSrgba rgba) { if (!gl2psSameColor(gl2ps->lastrgba, rgba)) { gl2psSetLastColor(rgba); gl2psPrintf("%g %g %g C\n", rgba[0], rgba[1], rgba[2]); } } static void gl2psResetPostScriptColor(void) { gl2ps->lastrgba[0] = gl2ps->lastrgba[1] = gl2ps->lastrgba[2] = -1.; } static void gl2psEndPostScriptLine(void) { int i; if (gl2ps->lastvertex.rgba[0] >= 0.) { gl2psPrintf("%g %g LE\n", gl2ps->lastvertex.xyz[0], gl2ps->lastvertex.xyz[1]); for (i = 0; i < 3; i++) { gl2ps->lastvertex.xyz[i] = -1.; } for (i = 0; i < 4; i++) { gl2ps->lastvertex.rgba[i] = -1.; } } } static void gl2psParseStipplePattern(GLushort pattern, GLint factor, int* nb, int array[10]) { int i, n; int on[8] = {0, 0, 0, 0, 0, 0, 0, 0}; int off[8] = {0, 0, 0, 0, 0, 0, 0, 0}; char tmp[16]; /* extract the 16 bits from the OpenGL stipple pattern */ for (n = 15; n >= 0; n--) { tmp[n] = (char)(pattern & 0x01); pattern >>= 1; } /* compute the on/off pixel sequence */ n = 0; for (i = 0; i < 8; i++) { while (n < 16 && !tmp[n]) { off[i]++; n++; } while (n < 16 && tmp[n]) { on[i]++; n++; } if (n >= 15) { i++; break; } } /* store the on/off array from right to left, starting with off pixels. The PostScript specification allows for at most 11 elements in the on/off array, so we limit ourselves to 5 on/off couples (our longest possible array is thus [on4 off4 on3 off3 on2 off2 on1 off1 on0 off0]) */ *nb = 0; for (n = i - 1; n >= 0; n--) { array[(*nb)++] = factor * on[n]; array[(*nb)++] = factor * off[n]; if (*nb == 10) { break; } } } static int gl2psPrintPostScriptDash(GLushort pattern, GLint factor, const char* str) { int len = 0, i, n, array[10]; if (pattern == gl2ps->lastpattern && factor == gl2ps->lastfactor) { return 0; } gl2ps->lastpattern = pattern; gl2ps->lastfactor = factor; if (!pattern || !factor) { /* solid line */ len += gl2psPrintf("[] 0 %s\n", str); } else { gl2psParseStipplePattern(pattern, factor, &n, array); len += gl2psPrintf("["); for (i = 0; i < n; i++) { if (i) { len += gl2psPrintf(" "); } len += gl2psPrintf("%d", array[i]); } len += gl2psPrintf("] 0 %s\n", str); } return len; } static void gl2psPrintPostScriptPrimitive(void* data) { int newline; GL2PSprimitive* prim; prim = *(GL2PSprimitive**)data; if ((gl2ps->options & GL2PS_OCCLUSION_CULL) && prim->culled) { return; } /* Every effort is made to draw lines as connected segments (i.e., using a single PostScript path): this is the only way to get nice line joins and to not restart the stippling for every line segment. So if the primitive to print is not a line we must first finish the current line (if any): */ if (prim->type != GL2PS_LINE) { gl2psEndPostScriptLine(); } switch (prim->type) { case GL2PS_POINT : gl2psPrintPostScriptColor(prim->verts[0].rgba); gl2psPrintf("%g %g %g P\n", prim->verts[0].xyz[0], prim->verts[0].xyz[1], 0.5 * prim->width); break; case GL2PS_LINE : if (!gl2psSamePosition(gl2ps->lastvertex.xyz, prim->verts[0].xyz) || !gl2psSameColor(gl2ps->lastrgba, prim->verts[0].rgba) || gl2ps->lastlinewidth != prim->width || gl2ps->lastpattern != prim->pattern || gl2ps->lastfactor != prim->factor) { /* End the current line if the new segment does not start where the last one ended, or if the color, the width or the stippling have changed (multi-stroking lines with changing colors is necessary until we use /shfill for lines; unfortunately this means that at the moment we can screw up line stippling for smooth-shaded lines) */ gl2psEndPostScriptLine(); newline = 1; } else { newline = 0; } if (gl2ps->lastlinewidth != prim->width) { gl2ps->lastlinewidth = prim->width; gl2psPrintf("%g W\n", gl2ps->lastlinewidth); } gl2psPrintPostScriptDash(prim->pattern, prim->factor, "setdash"); gl2psPrintPostScriptColor(prim->verts[0].rgba); gl2psPrintf("%g %g %s\n", prim->verts[0].xyz[0], prim->verts[0].xyz[1], newline ? "LS" : "L"); gl2ps->lastvertex = prim->verts[1]; break; case GL2PS_TRIANGLE : if (!gl2psVertsSameColor(prim)) { gl2psResetPostScriptColor(); gl2psPrintf("%g %g %g %g %g %g %g %g %g %g %g %g %g %g %g ST\n", prim->verts[2].xyz[0], prim->verts[2].xyz[1], prim->verts[2].rgba[0], prim->verts[2].rgba[1], prim->verts[2].rgba[2], prim->verts[1].xyz[0], prim->verts[1].xyz[1], prim->verts[1].rgba[0], prim->verts[1].rgba[1], prim->verts[1].rgba[2], prim->verts[0].xyz[0], prim->verts[0].xyz[1], prim->verts[0].rgba[0], prim->verts[0].rgba[1], prim->verts[0].rgba[2]); } else { gl2psPrintPostScriptColor(prim->verts[0].rgba); gl2psPrintf("%g %g %g %g %g %g T\n", prim->verts[2].xyz[0], prim->verts[2].xyz[1], prim->verts[1].xyz[0], prim->verts[1].xyz[1], prim->verts[0].xyz[0], prim->verts[0].xyz[1]); } break; case GL2PS_QUADRANGLE : gl2psMsg(GL2PS_WARNING, "There should not be any quad left to print"); break; case GL2PS_PIXMAP : gl2psPrintPostScriptPixmap(prim->verts[0].xyz[0], prim->verts[0].xyz[1], prim->data.image); break; case GL2PS_IMAGEMAP : if (prim->data.image->type != GL2PS_IMAGEMAP_WRITTEN) { gl2psPrintPostScriptColor(prim->verts[0].rgba); gl2psPrintPostScriptImagemap(prim->data.image->pixels[0], prim->data.image->pixels[1], prim->data.image->width, prim->data.image->height, (const unsigned char*)(&(prim->data.image->pixels[2]))); prim->data.image->type = GL2PS_IMAGEMAP_WRITTEN; } break; case GL2PS_TEXT : gl2psPrintPostScriptColor(prim->verts[0].rgba); gl2psPrintf("(%s) ", prim->data.text->str); if (prim->data.text->angle) { gl2psPrintf("%g ", prim->data.text->angle); } gl2psPrintf("%g %g %d /%s ", prim->verts[0].xyz[0], prim->verts[0].xyz[1], prim->data.text->fontsize, prim->data.text->fontname); switch (prim->data.text->alignment) { case GL2PS_TEXT_C: gl2psPrintf(prim->data.text->angle ? "SCCR\n" : "SCC\n"); break; case GL2PS_TEXT_CL: gl2psPrintf(prim->data.text->angle ? "SCLR\n" : "SCL\n"); break; case GL2PS_TEXT_CR: gl2psPrintf(prim->data.text->angle ? "SCRR\n" : "SCR\n"); break; case GL2PS_TEXT_B: gl2psPrintf(prim->data.text->angle ? "SBCR\n" : "SBC\n"); break; case GL2PS_TEXT_BR: gl2psPrintf(prim->data.text->angle ? "SBRR\n" : "SBR\n"); break; case GL2PS_TEXT_T: gl2psPrintf(prim->data.text->angle ? "STCR\n" : "STC\n"); break; case GL2PS_TEXT_TL: gl2psPrintf(prim->data.text->angle ? "STLR\n" : "STL\n"); break; case GL2PS_TEXT_TR: gl2psPrintf(prim->data.text->angle ? "STRR\n" : "STR\n"); break; case GL2PS_TEXT_BL: default: gl2psPrintf(prim->data.text->angle ? "SR\n" : "S\n"); break; } break; case GL2PS_SPECIAL : /* alignment contains the format for which the special output text is intended */ if (prim->data.text->alignment == GL2PS_PS || prim->data.text->alignment == GL2PS_EPS) { gl2psPrintf("%s\n", prim->data.text->str); } break; default : break; } } static void gl2psPrintPostScriptFooter(void) { gl2psPrintf("grestore\n" "showpage\n" "cleartomark\n" "%%%%PageTrailer\n" "%%%%Trailer\n" "end\n" "%%%%EOF\n"); gl2psPrintGzipFooter(); } static void gl2psPrintPostScriptBeginViewport(GLint viewport[4]) { GLint index; GLfloat rgba[4]; int x = viewport[0], y = viewport[1], w = viewport[2], h = viewport[3]; glRenderMode(GL_FEEDBACK); if (gl2ps->header) { gl2psPrintPostScriptHeader(); gl2ps->header = GL_FALSE; } gl2psPrintf("gsave\n" "1.0 1.0 scale\n"); if (gl2ps->options & GL2PS_DRAW_BACKGROUND) { if (gl2ps->colormode == GL_RGBA || gl2ps->colorsize == 0) { glGetFloatv(GL_COLOR_CLEAR_VALUE, rgba); } else { glGetIntegerv(GL_INDEX_CLEAR_VALUE, &index); rgba[0] = gl2ps->colormap[index][0]; rgba[1] = gl2ps->colormap[index][1]; rgba[2] = gl2ps->colormap[index][2]; rgba[3] = 1.0F; } gl2psPrintf("%g %g %g C\n" "newpath %d %d moveto %d %d lineto %d %d lineto %d %d lineto\n" "closepath fill\n", rgba[0], rgba[1], rgba[2], x, y, x+w, y, x+w, y+h, x, y+h); } gl2psPrintf("newpath %d %d moveto %d %d lineto %d %d lineto %d %d lineto\n" "closepath clip\n", x, y, x+w, y, x+w, y+h, x, y+h); } static GLint gl2psPrintPostScriptEndViewport(void) { GLint res; res = gl2psPrintPrimitives(); gl2psPrintf("grestore\n"); return res; } static void gl2psPrintPostScriptFinalPrimitive(void) { /* End any remaining line, if any */ gl2psEndPostScriptLine(); } /* definition of the PostScript and Encapsulated PostScript backends */ static GL2PSbackend gl2psPS = { gl2psPrintPostScriptHeader, gl2psPrintPostScriptFooter, gl2psPrintPostScriptBeginViewport, gl2psPrintPostScriptEndViewport, gl2psPrintPostScriptPrimitive, gl2psPrintPostScriptFinalPrimitive, "ps", "Postscript" }; static GL2PSbackend gl2psEPS = { gl2psPrintPostScriptHeader, gl2psPrintPostScriptFooter, gl2psPrintPostScriptBeginViewport, gl2psPrintPostScriptEndViewport, gl2psPrintPostScriptPrimitive, gl2psPrintPostScriptFinalPrimitive, "eps", "Encapsulated Postscript" }; /********************************************************************* * * LaTeX routines * *********************************************************************/ static void gl2psPrintTeXHeader(void) { char name[256]; time_t now; size_t i; if (gl2ps->filename && strlen(gl2ps->filename) < 256) { for (i = strlen(gl2ps->filename); i > 0; i--) { if (gl2ps->filename[i-1] == '.') { strncpy(name, gl2ps->filename, i-1); name[i-1] = '\0'; break; } } if (i == 0) { strcpy(name, gl2ps->filename); } } else { strcpy(name, "untitled"); } time(&now); fprintf(gl2ps->stream, "%% Title: %s\n" "%% Creator: GL2PS %d.%d.%d%s, %s\n" "%% For: %s\n" "%% CreationDate: %s", gl2ps->title, GL2PS_MAJOR_VERSION, GL2PS_MINOR_VERSION, GL2PS_PATCH_VERSION, GL2PS_EXTRA_VERSION, GL2PS_COPYRIGHT, gl2ps->producer, ctime(&now)); fprintf(gl2ps->stream, "\\setlength{\\unitlength}{1pt}\n" "\\begin{picture}(0,0)\n" "\\includegraphics{%s}\n" "\\end{picture}%%\n" "%s\\begin{picture}(%d,%d)(0,0)\n", name, (gl2ps->options & GL2PS_LANDSCAPE) ? "\\rotatebox{90}{" : "", (int)gl2ps->viewport[2], (int)gl2ps->viewport[3]); } static void gl2psPrintTeXPrimitive(void* data) { GL2PSprimitive* prim; prim = *(GL2PSprimitive**)data; switch (prim->type) { case GL2PS_TEXT : fprintf(gl2ps->stream, "\\fontsize{%d}{0}\n\\selectfont", prim->data.text->fontsize); fprintf(gl2ps->stream, "\\put(%g,%g){\\makebox(0,0)", prim->verts[0].xyz[0], prim->verts[0].xyz[1]); switch (prim->data.text->alignment) { case GL2PS_TEXT_C: fprintf(gl2ps->stream, "{"); break; case GL2PS_TEXT_CL: fprintf(gl2ps->stream, "[l]{"); break; case GL2PS_TEXT_CR: fprintf(gl2ps->stream, "[r]{"); break; case GL2PS_TEXT_B: fprintf(gl2ps->stream, "[b]{"); break; case GL2PS_TEXT_BR: fprintf(gl2ps->stream, "[br]{"); break; case GL2PS_TEXT_T: fprintf(gl2ps->stream, "[t]{"); break; case GL2PS_TEXT_TL: fprintf(gl2ps->stream, "[tl]{"); break; case GL2PS_TEXT_TR: fprintf(gl2ps->stream, "[tr]{"); break; case GL2PS_TEXT_BL: default: fprintf(gl2ps->stream, "[bl]{"); break; } if (prim->data.text->angle) { fprintf(gl2ps->stream, "\\rotatebox{%g}{", prim->data.text->angle); } fprintf(gl2ps->stream, "\\textcolor[rgb]{%g,%g,%g}{{%s}}", prim->verts[0].rgba[0], prim->verts[0].rgba[1], prim->verts[0].rgba[2], prim->data.text->str); if (prim->data.text->angle) { fprintf(gl2ps->stream, "}"); } fprintf(gl2ps->stream, "}}\n"); break; case GL2PS_SPECIAL : /* alignment contains the format for which the special output text is intended */ if (prim->data.text->alignment == GL2PS_TEX) { fprintf(gl2ps->stream, "%s\n", prim->data.text->str); } break; default : break; } } static void gl2psPrintTeXFooter(void) { fprintf(gl2ps->stream, "\\end{picture}%s\n", (gl2ps->options & GL2PS_LANDSCAPE) ? "}" : ""); } static void gl2psPrintTeXBeginViewport(GLint viewport[4]) { /* Trick to prevent compiler warnings. */ (void)(viewport[0]); glRenderMode(GL_FEEDBACK); if (gl2ps->header) { gl2psPrintTeXHeader(); gl2ps->header = GL_FALSE; } } static GLint gl2psPrintTeXEndViewport(void) { return gl2psPrintPrimitives(); } static void gl2psPrintTeXFinalPrimitive(void) { } /* definition of the LaTeX backend */ static GL2PSbackend gl2psTEX = { gl2psPrintTeXHeader, gl2psPrintTeXFooter, gl2psPrintTeXBeginViewport, gl2psPrintTeXEndViewport, gl2psPrintTeXPrimitive, gl2psPrintTeXFinalPrimitive, "tex", "LaTeX text" }; /********************************************************************* * * PDF routines * *********************************************************************/ static int gl2psPrintPDFCompressorType(void) { #if defined(GL2PS_HAVE_ZLIB) if (gl2ps->options & GL2PS_COMPRESS) { return fprintf(gl2ps->stream, "/Filter [/FlateDecode]\n"); } #endif return 0; } static int gl2psPrintPDFStrokeColor(GL2PSrgba rgba) { int i, offs = 0; gl2psSetLastColor(rgba); for (i = 0; i < 3; ++i) { if (GL2PS_ZERO(rgba[i])) { offs += gl2psPrintf("%.0f ", 0.); } else if (rgba[i] < 1e-4 || rgba[i] > 1e6) /* avoid %e formatting */ { offs += gl2psPrintf("%f ", rgba[i]); } else { offs += gl2psPrintf("%g ", rgba[i]); } } offs += gl2psPrintf("RG\n"); return offs; } static int gl2psPrintPDFFillColor(GL2PSrgba rgba) { int i, offs = 0; for (i = 0; i < 3; ++i) { if (GL2PS_ZERO(rgba[i])) { offs += gl2psPrintf("%.0f ", 0.); } else if (rgba[i] < 1e-4 || rgba[i] > 1e6) /* avoid %e formatting */ { offs += gl2psPrintf("%f ", rgba[i]); } else { offs += gl2psPrintf("%g ", rgba[i]); } } offs += gl2psPrintf("rg\n"); return offs; } static int gl2psPrintPDFLineWidth(GLfloat lw) { if (GL2PS_ZERO(lw)) { return gl2psPrintf("%.0f w\n", 0.); } else if (lw < 1e-4 || lw > 1e6) /* avoid %e formatting */ { return gl2psPrintf("%f w\n", lw); } else { return gl2psPrintf("%g w\n", lw); } } static void gl2psPutPDFText(GL2PSstring* text, int cnt, GLfloat x, GLfloat y) { GLfloat rad, crad, srad; if (text->angle == 0.0F) { gl2ps->streamlength += gl2psPrintf ("BT\n" "/F%d %d Tf\n" "%f %f Td\n" "(%s) Tj\n" "ET\n", cnt, text->fontsize, x, y, text->str); } else { rad = (GLfloat)M_PI * text->angle / 180.0F; srad = (GLfloat)sin(rad); crad = (GLfloat)cos(rad); gl2ps->streamlength += gl2psPrintf ("BT\n" "/F%d %d Tf\n" "%f %f %f %f %f %f Tm\n" "(%s) Tj\n" "ET\n", cnt, text->fontsize, crad, srad, -srad, crad, x, y, text->str); } } static void gl2psPutPDFImage(GL2PSimage* image, int cnt, GLfloat x, GLfloat y) { gl2ps->streamlength += gl2psPrintf ("q\n" "%d 0 0 %d %f %f cm\n" "/Im%d Do\n" "Q\n", (int)image->width, (int)image->height, x, y, cnt); } static void gl2psPDFstacksInit(void) { gl2ps->objects_stack = 7 /* FIXED_XREF_ENTRIES */ + 1; gl2ps->extgs_stack = 0; gl2ps->font_stack = 0; gl2ps->im_stack = 0; gl2ps->trgroupobjects_stack = 0; gl2ps->shader_stack = 0; gl2ps->mshader_stack = 0; } static void gl2psPDFgroupObjectInit(GL2PSpdfgroup* gro) { if (!gro) { return; } gro->ptrlist = NULL; gro->fontno = gro->gsno = gro->imno = gro->maskshno = gro->shno = gro->trgroupno = gro->fontobjno = gro->imobjno = gro->shobjno = gro->maskshobjno = gro->gsobjno = gro->trgroupobjno = -1; } /* Build up group objects and assign name and object numbers */ static void gl2psPDFgroupListInit(void) { int i; GL2PSprimitive* p = NULL; GL2PSpdfgroup gro; int lasttype = GL2PS_NO_TYPE; GL2PSrgba lastrgba = {-1.0F, -1.0F, -1.0F, -1.0F}; GLushort lastpattern = 0; GLint lastfactor = 0; GLfloat lastwidth = 1; GL2PStriangle lastt, tmpt; int lastTriangleWasNotSimpleWithSameColor = 0; if (!gl2ps->pdfprimlist) { return; } gl2ps->pdfgrouplist = gl2psListCreate(500, 500, sizeof(GL2PSpdfgroup)); gl2psInitTriangle(&lastt); for (i = 0; i < gl2psListNbr(gl2ps->pdfprimlist); ++i) { p = *(GL2PSprimitive**)gl2psListPointer(gl2ps->pdfprimlist, i); switch (p->type) { case GL2PS_PIXMAP: gl2psPDFgroupObjectInit(&gro); gro.ptrlist = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*)); gro.imno = gl2ps->im_stack++; gl2psListAdd(gro.ptrlist, &p); gl2psListAdd(gl2ps->pdfgrouplist, &gro); break; case GL2PS_TEXT: gl2psPDFgroupObjectInit(&gro); gro.ptrlist = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*)); gro.fontno = gl2ps->font_stack++; gl2psListAdd(gro.ptrlist, &p); gl2psListAdd(gl2ps->pdfgrouplist, &gro); break; case GL2PS_LINE: if (lasttype != p->type || lastwidth != p->width || lastpattern != p->pattern || lastfactor != p->factor || !gl2psSameColor(p->verts[0].rgba, lastrgba)) { gl2psPDFgroupObjectInit(&gro); gro.ptrlist = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*)); gl2psListAdd(gro.ptrlist, &p); gl2psListAdd(gl2ps->pdfgrouplist, &gro); } else { gl2psListAdd(gro.ptrlist, &p); } lastpattern = p->pattern; lastfactor = p->factor; lastwidth = p->width; lastrgba[0] = p->verts[0].rgba[0]; lastrgba[1] = p->verts[0].rgba[1]; lastrgba[2] = p->verts[0].rgba[2]; break; case GL2PS_POINT: if (lasttype != p->type || lastwidth != p->width || !gl2psSameColor(p->verts[0].rgba, lastrgba)) { gl2psPDFgroupObjectInit(&gro); gro.ptrlist = gl2psListCreate(1,2,sizeof(GL2PSprimitive*)); gl2psListAdd(gro.ptrlist, &p); gl2psListAdd(gl2ps->pdfgrouplist, &gro); } else { gl2psListAdd(gro.ptrlist, &p); } lastwidth = p->width; lastrgba[0] = p->verts[0].rgba[0]; lastrgba[1] = p->verts[0].rgba[1]; lastrgba[2] = p->verts[0].rgba[2]; break; case GL2PS_TRIANGLE: gl2psFillTriangleFromPrimitive(&tmpt, p, GL_TRUE); lastTriangleWasNotSimpleWithSameColor = !(tmpt.prop & T_CONST_COLOR && tmpt.prop & T_ALPHA_1) || !gl2psSameColor(tmpt.vertex[0].rgba, lastt.vertex[0].rgba); if (lasttype == p->type && tmpt.prop == lastt.prop && lastTriangleWasNotSimpleWithSameColor) { /* TODO Check here for last alpha */ gl2psListAdd(gro.ptrlist, &p); } else { gl2psPDFgroupObjectInit(&gro); gro.ptrlist = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*)); gl2psListAdd(gro.ptrlist, &p); gl2psListAdd(gl2ps->pdfgrouplist, &gro); } lastt = tmpt; break; default: break; } lasttype = p->type; } } static void gl2psSortOutTrianglePDFgroup(GL2PSpdfgroup* gro) { GL2PStriangle t; GL2PSprimitive* prim = NULL; if (!gro) { return; } if (!gl2psListNbr(gro->ptrlist)) { return; } prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, 0); if (prim->type != GL2PS_TRIANGLE) { return; } gl2psFillTriangleFromPrimitive(&t, prim, GL_TRUE); if (t.prop & T_CONST_COLOR && t.prop & T_ALPHA_LESS_1) { gro->gsno = gl2ps->extgs_stack++; gro->gsobjno = gl2ps->objects_stack ++; } else if (t.prop & T_CONST_COLOR && t.prop & T_VAR_ALPHA) { gro->gsno = gl2ps->extgs_stack++; gro->gsobjno = gl2ps->objects_stack++; gro->trgroupno = gl2ps->trgroupobjects_stack++; gro->trgroupobjno = gl2ps->objects_stack++; gro->maskshno = gl2ps->mshader_stack++; gro->maskshobjno = gl2ps->objects_stack++; } else if (t.prop & T_VAR_COLOR && t.prop & T_ALPHA_1) { gro->shno = gl2ps->shader_stack++; gro->shobjno = gl2ps->objects_stack++; } else if (t.prop & T_VAR_COLOR && t.prop & T_ALPHA_LESS_1) { gro->gsno = gl2ps->extgs_stack++; gro->gsobjno = gl2ps->objects_stack++; gro->shno = gl2ps->shader_stack++; gro->shobjno = gl2ps->objects_stack++; } else if (t.prop & T_VAR_COLOR && t.prop & T_VAR_ALPHA) { gro->gsno = gl2ps->extgs_stack++; gro->gsobjno = gl2ps->objects_stack++; gro->shno = gl2ps->shader_stack++; gro->shobjno = gl2ps->objects_stack++; gro->trgroupno = gl2ps->trgroupobjects_stack++; gro->trgroupobjno = gl2ps->objects_stack++; gro->maskshno = gl2ps->mshader_stack++; gro->maskshobjno = gl2ps->objects_stack++; } } /* Main stream data */ static void gl2psPDFgroupListWriteMainStream(void) { int i, j, lastel; GL2PSprimitive* prim = NULL, *prev = NULL; GL2PSpdfgroup* gro; GL2PStriangle t; if (!gl2ps->pdfgrouplist) { return; } for (i = 0; i < gl2psListNbr(gl2ps->pdfgrouplist); ++i) { gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist, i); lastel = gl2psListNbr(gro->ptrlist) - 1; if (lastel < 0) { continue; } prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, 0); switch (prim->type) { case GL2PS_POINT: gl2ps->streamlength += gl2psPrintf("1 J\n"); gl2ps->streamlength += gl2psPrintPDFLineWidth(prim->width); gl2ps->streamlength += gl2psPrintPDFStrokeColor(prim->verts[0].rgba); for (j = 0; j <= lastel; ++j) { prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j); gl2ps->streamlength += gl2psPrintf("%f %f m %f %f l\n", prim->verts[0].xyz[0], prim->verts[0].xyz[1], prim->verts[0].xyz[0], prim->verts[0].xyz[1]); } gl2ps->streamlength += gl2psPrintf("S\n"); gl2ps->streamlength += gl2psPrintf("0 J\n"); break; case GL2PS_LINE: /* We try to use as few paths as possible to draw lines, in order to get nice stippling even when the individual segments are smaller than the stipple */ gl2ps->streamlength += gl2psPrintPDFLineWidth(prim->width); gl2ps->streamlength += gl2psPrintPDFStrokeColor(prim->verts[0].rgba); gl2ps->streamlength += gl2psPrintPostScriptDash(prim->pattern, prim->factor, "d"); /* start new path */ gl2ps->streamlength += gl2psPrintf("%f %f m\n", prim->verts[0].xyz[0], prim->verts[0].xyz[1]); for (j = 1; j <= lastel; ++j) { prev = prim; prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j); if (!gl2psSamePosition(prim->verts[0].xyz, prev->verts[1].xyz)) { /* the starting point of the new segment does not match the end point of the previous line, so we end the current path and start a new one */ gl2ps->streamlength += gl2psPrintf("%f %f l\n", prev->verts[1].xyz[0], prev->verts[1].xyz[1]); gl2ps->streamlength += gl2psPrintf("%f %f m\n", prim->verts[0].xyz[0], prim->verts[0].xyz[1]); } else { /* the two segements are connected, so we just append to the current path */ gl2ps->streamlength += gl2psPrintf("%f %f l\n", prim->verts[0].xyz[0], prim->verts[0].xyz[1]); } } /* end last path */ gl2ps->streamlength += gl2psPrintf("%f %f l\n", prim->verts[1].xyz[0], prim->verts[1].xyz[1]); gl2ps->streamlength += gl2psPrintf("S\n"); break; case GL2PS_TRIANGLE: gl2psFillTriangleFromPrimitive(&t, prim, GL_TRUE); gl2psSortOutTrianglePDFgroup(gro); /* No alpha and const color: Simple PDF draw orders */ if (t.prop & T_CONST_COLOR && t.prop & T_ALPHA_1) { gl2ps->streamlength += gl2psPrintPDFFillColor(t.vertex[0].rgba); for (j = 0; j <= lastel; ++j) { prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j); gl2psFillTriangleFromPrimitive(&t, prim, GL_FALSE); gl2ps->streamlength += gl2psPrintf("%f %f m\n" "%f %f l\n" "%f %f l\n" "h f\n", t.vertex[0].xyz[0], t.vertex[0].xyz[1], t.vertex[1].xyz[0], t.vertex[1].xyz[1], t.vertex[2].xyz[0], t.vertex[2].xyz[1]); } } /* Const alpha < 1 and const color: Simple PDF draw orders and an extra extended Graphics State for the alpha const */ else if (t.prop & T_CONST_COLOR && t.prop & T_ALPHA_LESS_1) { gl2ps->streamlength += gl2psPrintf("q\n" "/GS%d gs\n", gro->gsno); gl2ps->streamlength += gl2psPrintPDFFillColor(prim->verts[0].rgba); for (j = 0; j <= lastel; ++j) { prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j); gl2psFillTriangleFromPrimitive(&t, prim, GL_FALSE); gl2ps->streamlength += gl2psPrintf("%f %f m\n" "%f %f l\n" "%f %f l\n" "h f\n", t.vertex[0].xyz[0], t.vertex[0].xyz[1], t.vertex[1].xyz[0], t.vertex[1].xyz[1], t.vertex[2].xyz[0], t.vertex[2].xyz[1]); } gl2ps->streamlength += gl2psPrintf("Q\n"); } /* Variable alpha and const color: Simple PDF draw orders and an extra extended Graphics State + Xobject + Shader object for the alpha mask */ else if (t.prop & T_CONST_COLOR && t.prop & T_VAR_ALPHA) { gl2ps->streamlength += gl2psPrintf("q\n" "/GS%d gs\n" "/TrG%d Do\n", gro->gsno, gro->trgroupno); gl2ps->streamlength += gl2psPrintPDFFillColor(prim->verts[0].rgba); for (j = 0; j <= lastel; ++j) { prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j); gl2psFillTriangleFromPrimitive(&t, prim, GL_FALSE); gl2ps->streamlength += gl2psPrintf("%f %f m\n" "%f %f l\n" "%f %f l\n" "h f\n", t.vertex[0].xyz[0], t.vertex[0].xyz[1], t.vertex[1].xyz[0], t.vertex[1].xyz[1], t.vertex[2].xyz[0], t.vertex[2].xyz[1]); } gl2ps->streamlength += gl2psPrintf("Q\n"); } /* Variable color and no alpha: Shader Object for the colored triangle(s) */ else if (t.prop & T_VAR_COLOR && t.prop & T_ALPHA_1) { gl2ps->streamlength += gl2psPrintf("/Sh%d sh\n", gro->shno); } /* Variable color and const alpha < 1: Shader Object for the colored triangle(s) and an extra extended Graphics State for the alpha const */ else if (t.prop & T_VAR_COLOR && t.prop & T_ALPHA_LESS_1) { gl2ps->streamlength += gl2psPrintf("q\n" "/GS%d gs\n" "/Sh%d sh\n" "Q\n", gro->gsno, gro->shno); } /* Variable alpha and color: Shader Object for the colored triangle(s) and an extra extended Graphics State + Xobject + Shader object for the alpha mask */ else if (t.prop & T_VAR_COLOR && t.prop & T_VAR_ALPHA) { gl2ps->streamlength += gl2psPrintf("q\n" "/GS%d gs\n" "/TrG%d Do\n" "/Sh%d sh\n" "Q\n", gro->gsno, gro->trgroupno, gro->shno); } break; case GL2PS_PIXMAP: for (j = 0; j <= lastel; ++j) { prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j); gl2psPutPDFImage(prim->data.image, gro->imno, prim->verts[0].xyz[0], prim->verts[0].xyz[1]); } break; case GL2PS_TEXT: for (j = 0; j <= lastel; ++j) { prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j); gl2ps->streamlength += gl2psPrintPDFFillColor(prim->verts[0].rgba); gl2psPutPDFText(prim->data.text, gro->fontno, prim->verts[0].xyz[0], prim->verts[0].xyz[1]); } break; default: break; } } } /* Graphics State names */ static int gl2psPDFgroupListWriteGStateResources(void) { GL2PSpdfgroup* gro; int offs = 0; int i; offs += fprintf(gl2ps->stream, "/ExtGState\n" "<<\n" "/GSa 7 0 R\n"); for (i = 0; i < gl2psListNbr(gl2ps->pdfgrouplist); ++i) { gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist, i); if (gro->gsno >= 0) { offs += fprintf(gl2ps->stream, "/GS%d %d 0 R\n", gro->gsno, gro->gsobjno); } } offs += fprintf(gl2ps->stream, ">>\n"); return offs; } /* Main Shader names */ static int gl2psPDFgroupListWriteShaderResources(void) { GL2PSpdfgroup* gro; int offs = 0; int i; offs += fprintf(gl2ps->stream, "/Shading\n" "<<\n"); for (i = 0; i < gl2psListNbr(gl2ps->pdfgrouplist); ++i) { gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist, i); if (gro->shno >= 0) { offs += fprintf(gl2ps->stream, "/Sh%d %d 0 R\n", gro->shno, gro->shobjno); } if (gro->maskshno >= 0) { offs += fprintf(gl2ps->stream, "/TrSh%d %d 0 R\n", gro->maskshno, gro->maskshobjno); } } offs += fprintf(gl2ps->stream,">>\n"); return offs; } /* Images & Mask Shader XObject names */ static int gl2psPDFgroupListWriteXObjectResources(void) { int i; GL2PSprimitive* p = NULL; GL2PSpdfgroup* gro; int offs = 0; offs += fprintf(gl2ps->stream, "/XObject\n" "<<\n"); for (i = 0; i < gl2psListNbr(gl2ps->pdfgrouplist); ++i) { gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist, i); if (!gl2psListNbr(gro->ptrlist)) { continue; } p = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, 0); switch (p->type) { case GL2PS_PIXMAP: gro->imobjno = gl2ps->objects_stack++; if (GL_RGBA == p->data.image->format) /* reserve one object for image mask */ { gl2ps->objects_stack++; } offs += fprintf(gl2ps->stream, "/Im%d %d 0 R\n", gro->imno, gro->imobjno); case GL2PS_TRIANGLE: if (gro->trgroupno >=0) { offs += fprintf(gl2ps->stream, "/TrG%d %d 0 R\n", gro->trgroupno, gro->trgroupobjno); } break; default: break; } } offs += fprintf(gl2ps->stream,">>\n"); return offs; } /* Font names */ static int gl2psPDFgroupListWriteFontResources(void) { int i; GL2PSpdfgroup* gro; int offs = 0; offs += fprintf(gl2ps->stream, "/Font\n<<\n"); for (i = 0; i < gl2psListNbr(gl2ps->pdfgrouplist); ++i) { gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist, i); if (gro->fontno < 0) { continue; } gro->fontobjno = gl2ps->objects_stack++; offs += fprintf(gl2ps->stream, "/F%d %d 0 R\n", gro->fontno, gro->fontobjno); } offs += fprintf(gl2ps->stream, ">>\n"); return offs; } static void gl2psPDFgroupListDelete(void) { int i; GL2PSpdfgroup* gro = NULL; if (!gl2ps->pdfgrouplist) { return; } for (i = 0; i < gl2psListNbr(gl2ps->pdfgrouplist); ++i) { gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist,i); gl2psListDelete(gro->ptrlist); } gl2psListDelete(gl2ps->pdfgrouplist); gl2ps->pdfgrouplist = NULL; } /* Print 1st PDF object - file info */ static int gl2psPrintPDFInfo(void) { int offs; time_t now; struct tm* newtime; time(&now); newtime = gmtime(&now); offs = fprintf(gl2ps->stream, "1 0 obj\n" "<<\n" "/Title (%s)\n" "/Creator (GL2PS %d.%d.%d%s, %s)\n" "/Producer (%s)\n", gl2ps->title, GL2PS_MAJOR_VERSION, GL2PS_MINOR_VERSION, GL2PS_PATCH_VERSION, GL2PS_EXTRA_VERSION, GL2PS_COPYRIGHT, gl2ps->producer); if (!newtime) { offs += fprintf(gl2ps->stream, ">>\n" "endobj\n"); return offs; } offs += fprintf(gl2ps->stream, "/CreationDate (D:%d%02d%02d%02d%02d%02d)\n" ">>\n" "endobj\n", newtime->tm_year+1900, newtime->tm_mon+1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec); return offs; } /* Create catalog and page structure - 2nd and 3th PDF object */ static int gl2psPrintPDFCatalog(void) { return fprintf(gl2ps->stream, "2 0 obj\n" "<<\n" "/Type /Catalog\n" "/Pages 3 0 R\n" ">>\n" "endobj\n"); } static int gl2psPrintPDFPages(void) { return fprintf(gl2ps->stream, "3 0 obj\n" "<<\n" "/Type /Pages\n" "/Kids [6 0 R]\n" "/Count 1\n" ">>\n" "endobj\n"); } /* Open stream for data - graphical objects, fonts etc. PDF object 4 */ static int gl2psOpenPDFDataStream(void) { int offs = 0; offs += fprintf(gl2ps->stream, "4 0 obj\n" "<<\n" "/Length 5 0 R\n"); offs += gl2psPrintPDFCompressorType(); offs += fprintf(gl2ps->stream, ">>\n" "stream\n"); return offs; } /* Stream setup - Graphics state, fill background if allowed */ static int gl2psOpenPDFDataStreamWritePreface(void) { int offs; offs = gl2psPrintf("/GSa gs\n"); if (gl2ps->options & GL2PS_DRAW_BACKGROUND) { offs += gl2psPrintPDFFillColor(gl2ps->bgcolor); offs += gl2psPrintf("%d %d %d %d re\n", (int)gl2ps->viewport[0], (int)gl2ps->viewport[1], (int)gl2ps->viewport[2], (int)gl2ps->viewport[3]); offs += gl2psPrintf("f\n"); } return offs; } /* Use the functions above to create the first part of the PDF*/ static void gl2psPrintPDFHeader(void) { int offs = 0; gl2ps->pdfprimlist = gl2psListCreate(500, 500, sizeof(GL2PSprimitive*)); gl2psPDFstacksInit(); gl2ps->xreflist = (size_t*)gl2psMalloc(sizeof(size_t) * gl2ps->objects_stack); #if defined(GL2PS_HAVE_ZLIB) if (gl2ps->options & GL2PS_COMPRESS) { gl2psSetupCompress(); } #endif gl2ps->xreflist[0] = 0; offs += fprintf(gl2ps->stream, "%%PDF-1.4\n"); gl2ps->xreflist[1] = offs; offs += gl2psPrintPDFInfo(); gl2ps->xreflist[2] = offs; offs += gl2psPrintPDFCatalog(); gl2ps->xreflist[3] = offs; offs += gl2psPrintPDFPages(); gl2ps->xreflist[4] = offs; offs += gl2psOpenPDFDataStream(); gl2ps->xreflist[5] = offs; /* finished in gl2psPrintPDFFooter */ gl2ps->streamlength = gl2psOpenPDFDataStreamWritePreface(); } /* The central primitive drawing */ static void gl2psPrintPDFPrimitive(void* data) { GL2PSprimitive* prim = *(GL2PSprimitive**)data; if ((gl2ps->options & GL2PS_OCCLUSION_CULL) && prim->culled) { return; } prim = gl2psCopyPrimitive(prim); /* deep copy */ gl2psListAdd(gl2ps->pdfprimlist, &prim); } /* close stream and ... */ static int gl2psClosePDFDataStream(void) { int offs = 0; #if defined(GL2PS_HAVE_ZLIB) if (gl2ps->options & GL2PS_COMPRESS) { if (Z_OK != gl2psDeflate()) { gl2psMsg(GL2PS_ERROR, "Zlib deflate error"); } else { fwrite(gl2ps->compress->dest, gl2ps->compress->destLen, 1, gl2ps->stream); } gl2ps->streamlength += gl2ps->compress->destLen; offs += gl2ps->streamlength; gl2psFreeCompress(); } #endif offs += fprintf(gl2ps->stream, "endstream\n" "endobj\n"); return offs; } /* ... write the now known length object */ static int gl2psPrintPDFDataStreamLength(size_t val) { return fprintf(gl2ps->stream, "5 0 obj\n" "%zu\n" "endobj\n", val); } /* Put the info created before in PDF objects */ static int gl2psPrintPDFOpenPage(void) { int offs; /* Write fixed part */ offs = fprintf(gl2ps->stream, "6 0 obj\n" "<<\n" "/Type /Page\n" "/Parent 3 0 R\n" "/MediaBox [%d %d %d %d]\n", (int)gl2ps->viewport[0], (int)gl2ps->viewport[1], (int)gl2ps->viewport[2], (int)gl2ps->viewport[3]); if (gl2ps->options & GL2PS_LANDSCAPE) { offs += fprintf(gl2ps->stream, "/Rotate -90\n"); } offs += fprintf(gl2ps->stream, "/Contents 4 0 R\n" "/Resources\n" "<<\n" "/ProcSet [/PDF /Text /ImageB /ImageC] %%/ImageI\n"); return offs; /* End fixed part, proceeds in gl2psPDFgroupListWriteVariableResources() */ } static int gl2psPDFgroupListWriteVariableResources(void) { int offs = 0; /* a) Graphics States for shader alpha masks*/ offs += gl2psPDFgroupListWriteGStateResources(); /* b) Shader and shader masks */ offs += gl2psPDFgroupListWriteShaderResources(); /* c) XObjects (Images & Shader Masks) */ offs += gl2psPDFgroupListWriteXObjectResources(); /* d) Fonts */ offs += gl2psPDFgroupListWriteFontResources(); /* End resources and page */ offs += fprintf(gl2ps->stream, ">>\n" ">>\n" "endobj\n"); return offs; } /* Standard Graphics State */ static int gl2psPrintPDFGSObject(void) { return fprintf(gl2ps->stream, "7 0 obj\n" "<<\n" "/Type /ExtGState\n" "/SA false\n" "/SM 0.02\n" "/OP false\n" "/op false\n" "/OPM 0\n" "/BG2 /Default\n" "/UCR2 /Default\n" "/TR2 /Default\n" ">>\n" "endobj\n"); } /* Put vertex' edge flag (8bit) and coordinates (32bit) in shader stream */ static size_t gl2psPrintPDFShaderStreamDataCoord(GL2PSvertex* vertex, size_t (*action)(unsigned long data, size_t size), GLfloat dx, GLfloat dy, GLfloat xmin, GLfloat ymin) { size_t offs = 0; unsigned long imap; GLfloat diff; double dmax = ~1UL; char edgeflag = 0; /* FIXME: temp bux fix for 64 bit archs: */ if (sizeof(unsigned long) == 8) { dmax = dmax - 2048.; } offs += (*action)(edgeflag, 1); /* The Shader stream in PDF requires to be in a 'big-endian' order */ if (GL2PS_ZERO(dx * dy)) { offs += (*action)(0, 4); offs += (*action)(0, 4); } else { diff = (vertex->xyz[0] - xmin) / dx; if (diff > 1) { diff = 1.0F; } else if (diff < 0) { diff = 0.0F; } imap = (unsigned long)(diff * dmax); offs += (*action)(imap, 4); diff = (vertex->xyz[1] - ymin) / dy; if (diff > 1) { diff = 1.0F; } else if (diff < 0) { diff = 0.0F; } imap = (unsigned long)(diff * dmax); offs += (*action)(imap, 4); } return offs; } /* Put vertex' rgb value (8bit for every component) in shader stream */ static size_t gl2psPrintPDFShaderStreamDataRGB(GL2PSvertex* vertex, size_t (*action)(unsigned long data, size_t size)) { size_t offs = 0; unsigned long imap; double dmax = ~1UL; /* FIXME: temp bux fix for 64 bit archs: */ if (sizeof(unsigned long) == 8) { dmax = dmax - 2048.; } imap = (unsigned long)((vertex->rgba[0]) * dmax); offs += (*action)(imap, 1); imap = (unsigned long)((vertex->rgba[1]) * dmax); offs += (*action)(imap, 1); imap = (unsigned long)((vertex->rgba[2]) * dmax); offs += (*action)(imap, 1); return offs; } /* Put vertex' alpha (8/16bit) in shader stream */ static size_t gl2psPrintPDFShaderStreamDataAlpha(GL2PSvertex* vertex, size_t (*action)(unsigned long data, size_t size), int sigbyte) { size_t offs = 0; unsigned long imap; double dmax = ~1UL; /* FIXME: temp bux fix for 64 bit archs: */ if (sizeof(unsigned long) == 8) { dmax = dmax - 2048.; } if (sigbyte != 8 && sigbyte != 16) { sigbyte = 8; } sigbyte /= 8; imap = (unsigned long)((vertex->rgba[3]) * dmax); offs += (*action)(imap, sigbyte); return offs; } /* Put a triangles raw data in shader stream */ static size_t gl2psPrintPDFShaderStreamData(GL2PStriangle* triangle, GLfloat dx, GLfloat dy, GLfloat xmin, GLfloat ymin, size_t (*action)(unsigned long data, size_t size), int gray) { int i; size_t offs = 0; GL2PSvertex v; if (gray && gray != 8 && gray != 16) { gray = 8; } for (i = 0; i < 3; ++i) { offs += gl2psPrintPDFShaderStreamDataCoord(&triangle->vertex[i], action, dx, dy, xmin, ymin); if (gray) { v = triangle->vertex[i]; offs += gl2psPrintPDFShaderStreamDataAlpha(&v, action, gray); } else { offs += gl2psPrintPDFShaderStreamDataRGB(&triangle->vertex[i], action); } } return offs; } static void gl2psPDFRectHull(GLfloat* xmin, GLfloat* xmax, GLfloat* ymin, GLfloat* ymax, GL2PStriangle* triangles, int cnt) { int i, j; *xmin = triangles[0].vertex[0].xyz[0]; *xmax = triangles[0].vertex[0].xyz[0]; *ymin = triangles[0].vertex[0].xyz[1]; *ymax = triangles[0].vertex[0].xyz[1]; for (i = 0; i < cnt; ++i) { for (j = 0; j < 3; ++j) { if (*xmin > triangles[i].vertex[j].xyz[0]) { *xmin = triangles[i].vertex[j].xyz[0]; } if (*xmax < triangles[i].vertex[j].xyz[0]) { *xmax = triangles[i].vertex[j].xyz[0]; } if (*ymin > triangles[i].vertex[j].xyz[1]) { *ymin = triangles[i].vertex[j].xyz[1]; } if (*ymax < triangles[i].vertex[j].xyz[1]) { *ymax = triangles[i].vertex[j].xyz[1]; } } } } /* Writes shaded triangle gray == 0 means write RGB triangles gray == 8 8bit-grayscale (for alpha masks) gray == 16 16bit-grayscale (for alpha masks) */ static size_t gl2psPrintPDFShader(int obj, GL2PStriangle* triangles, int size, int gray) { int i, vertexbytes, done = 0; size_t offs = 0; GLfloat xmin, xmax, ymin, ymax; switch (gray) { case 0: vertexbytes = 1+4+4+1+1+1; break; case 8: vertexbytes = 1+4+4+1; break; case 16: vertexbytes = 1+4+4+2; break; default: gray = 8; vertexbytes = 1+4+4+1; break; } gl2psPDFRectHull(&xmin, &xmax, &ymin, &ymax, triangles, size); offs += fprintf(gl2ps->stream, "%d 0 obj\n" "<< " "/ShadingType 4 " "/ColorSpace %s " "/BitsPerCoordinate 32 " "/BitsPerComponent %d " "/BitsPerFlag 8 " "/Decode [%f %f %f %f 0 1 %s] ", obj, (gray) ? "/DeviceGray" : "/DeviceRGB", (gray) ? gray : 8, xmin, xmax, ymin, ymax, (gray) ? "" : "0 1 0 1"); #if defined(GL2PS_HAVE_ZLIB) if (gl2ps->options & GL2PS_COMPRESS) { gl2psAllocCompress(vertexbytes * size * 3); for (i = 0; i < size; ++i) gl2psPrintPDFShaderStreamData(&triangles[i], xmax-xmin, ymax-ymin, xmin, ymin, gl2psWriteBigEndianCompress, gray); if (Z_OK == gl2psDeflate() && 23 + gl2ps->compress->destLen < gl2ps->compress->srcLen) { offs += gl2psPrintPDFCompressorType(); offs += fprintf(gl2ps->stream, "/Length %d " ">>\n" "stream\n", (int)gl2ps->compress->destLen); offs += gl2ps->compress->destLen * fwrite(gl2ps->compress->dest, gl2ps->compress->destLen, 1, gl2ps->stream); done = 1; } gl2psFreeCompress(); } #endif if (!done) { /* no compression, or too long after compression, or compress error -> write non-compressed entry */ offs += fprintf(gl2ps->stream, "/Length %d " ">>\n" "stream\n", vertexbytes * 3 * size); for (i = 0; i < size; ++i) offs += gl2psPrintPDFShaderStreamData(&triangles[i], xmax-xmin, ymax-ymin, xmin, ymin, gl2psWriteBigEndian, gray); } offs += fprintf(gl2ps->stream, "\nendstream\n" "endobj\n"); return offs; } /* Writes a XObject for a shaded triangle mask */ static int gl2psPrintPDFShaderMask(int obj, int childobj) { int offs = 0; size_t len; offs += fprintf(gl2ps->stream, "%d 0 obj\n" "<<\n" "/Type /XObject\n" "/Subtype /Form\n" "/BBox [ %d %d %d %d ]\n" "/Group \n<<\n/S /Transparency /CS /DeviceRGB\n" ">>\n", obj, (int)gl2ps->viewport[0], (int)gl2ps->viewport[1], (int)gl2ps->viewport[2], (int)gl2ps->viewport[3]); len = (childobj>0) ? strlen("/TrSh sh\n") + (int)log10((double)childobj)+1 : strlen("/TrSh0 sh\n"); offs += fprintf(gl2ps->stream, "/Length %zu\n" ">>\n" "stream\n", len); offs += fprintf(gl2ps->stream, "/TrSh%d sh\n", childobj); offs += fprintf(gl2ps->stream, "endstream\n" "endobj\n"); return offs; } /* Writes a Extended graphics state for a shaded triangle mask if simplealpha ist true the childobj argument is ignored and a /ca statement will be written instead */ static int gl2psPrintPDFShaderExtGS(int obj, int childobj) { int offs = 0; offs += fprintf(gl2ps->stream, "%d 0 obj\n" "<<\n", obj); offs += fprintf(gl2ps->stream, "/SMask << /S /Alpha /G %d 0 R >> ", childobj); offs += fprintf(gl2ps->stream, ">>\n" "endobj\n"); return offs; } /* a simple graphics state */ static int gl2psPrintPDFShaderSimpleExtGS(int obj, GLfloat alpha) { int offs = 0; offs += fprintf(gl2ps->stream, "%d 0 obj\n" "<<\n" "/ca %g" ">>\n" "endobj\n", obj, alpha); return offs; } /* Similar groups of functions for pixmaps and text */ static int gl2psPrintPDFPixmapStreamData(GL2PSimage* im, size_t (*action)(unsigned long data, size_t size), int gray) { int x, y, shift; GLfloat r, g, b, a; if (im->format != GL_RGBA && gray) { return 0; } if (gray && gray != 8 && gray != 16) { gray = 8; } gray /= 8; shift = (sizeof(unsigned long) - 1) * 8; for (y = 0; y < im->height; ++y) { for (x = 0; x < im->width; ++x) { a = gl2psGetRGB(im, x, y, &r, &g, &b); if (im->format == GL_RGBA && gray) { (*action)((unsigned long)(a * 255) << shift, gray); } else { (*action)((unsigned long)(r * 255) << shift, 1); (*action)((unsigned long)(g * 255) << shift, 1); (*action)((unsigned long)(b * 255) << shift, 1); } } } switch (gray) { case 0: return 3 * im->width * im->height; case 1: return im->width * im->height; case 2: return 2 * im->width * im->height; default: return 3 * im->width * im->height; } } static int gl2psPrintPDFPixmap(int obj, int childobj, GL2PSimage* im, int gray) { int offs = 0, done = 0, sigbytes = 3; if (gray && gray !=8 && gray != 16) { gray = 8; } if (gray) { sigbytes = gray / 8; } offs += fprintf(gl2ps->stream, "%d 0 obj\n" "<<\n" "/Type /XObject\n" "/Subtype /Image\n" "/Width %d\n" "/Height %d\n" "/ColorSpace %s \n" "/BitsPerComponent 8\n", obj, (int)im->width, (int)im->height, (gray) ? "/DeviceGray" : "/DeviceRGB"); if (GL_RGBA == im->format && gray == 0) { offs += fprintf(gl2ps->stream, "/SMask %d 0 R\n", childobj); } #if defined(GL2PS_HAVE_ZLIB) if (gl2ps->options & GL2PS_COMPRESS) { gl2psAllocCompress((int)(im->width * im->height * sigbytes)); gl2psPrintPDFPixmapStreamData(im, gl2psWriteBigEndianCompress, gray); if (Z_OK == gl2psDeflate() && 23 + gl2ps->compress->destLen < gl2ps->compress->srcLen) { offs += gl2psPrintPDFCompressorType(); offs += fprintf(gl2ps->stream, "/Length %d " ">>\n" "stream\n", (int)gl2ps->compress->destLen); offs += gl2ps->compress->destLen * fwrite(gl2ps->compress->dest, gl2ps->compress->destLen, 1, gl2ps->stream); done = 1; } gl2psFreeCompress(); } #endif if (!done) { /* no compression, or too long after compression, or compress error -> write non-compressed entry */ offs += fprintf(gl2ps->stream, "/Length %d " ">>\n" "stream\n", (int)(im->width * im->height * sigbytes)); offs += gl2psPrintPDFPixmapStreamData(im, gl2psWriteBigEndian, gray); } offs += fprintf(gl2ps->stream, "\nendstream\n" "endobj\n"); return offs; } static int gl2psPrintPDFText(int obj, GL2PSstring* s, int fontnumber) { int offs = 0; offs += fprintf(gl2ps->stream, "%d 0 obj\n" "<<\n" "/Type /Font\n" "/Subtype /Type1\n" "/Name /F%d\n" "/BaseFont /%s\n" "/Encoding /MacRomanEncoding\n" ">>\n" "endobj\n", obj, fontnumber, s->fontname); return offs; } /* Write the physical objects */ static size_t gl2psPDFgroupListWriteObjects(size_t entryoffs) { int i,j; GL2PSprimitive* p = NULL; GL2PSpdfgroup* gro; size_t offs = entryoffs; GL2PStriangle* triangles; int size = 0; if (!gl2ps->pdfgrouplist) { return offs; } for (i = 0; i < gl2psListNbr(gl2ps->pdfgrouplist); ++i) { gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist, i); if (!gl2psListNbr(gro->ptrlist)) { continue; } p = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, 0); switch (p->type) { case GL2PS_POINT: break; case GL2PS_LINE: break; case GL2PS_TRIANGLE: size = gl2psListNbr(gro->ptrlist); triangles = (GL2PStriangle*)gl2psMalloc(sizeof(GL2PStriangle) * size); for (j = 0; j < size; ++j) { p = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j); gl2psFillTriangleFromPrimitive(&triangles[j], p, GL_TRUE); } if (triangles[0].prop & T_VAR_COLOR) { gl2ps->xreflist[gro->shobjno] = offs; offs += gl2psPrintPDFShader(gro->shobjno, triangles, size, 0); } if (triangles[0].prop & T_ALPHA_LESS_1) { gl2ps->xreflist[gro->gsobjno] = offs; offs += gl2psPrintPDFShaderSimpleExtGS(gro->gsobjno, triangles[0].vertex[0].rgba[3]); } if (triangles[0].prop & T_VAR_ALPHA) { gl2ps->xreflist[gro->gsobjno] = offs; offs += gl2psPrintPDFShaderExtGS(gro->gsobjno, gro->trgroupobjno); gl2ps->xreflist[gro->trgroupobjno] = offs; offs += gl2psPrintPDFShaderMask(gro->trgroupobjno, gro->maskshno); gl2ps->xreflist[gro->maskshobjno] = offs; offs += gl2psPrintPDFShader(gro->maskshobjno, triangles, size, 8); } gl2psFree(triangles); break; case GL2PS_PIXMAP: gl2ps->xreflist[gro->imobjno] = offs; offs += gl2psPrintPDFPixmap(gro->imobjno, gro->imobjno+1, p->data.image, 0); if (p->data.image->format == GL_RGBA) { gl2ps->xreflist[gro->imobjno+1] = offs; offs += gl2psPrintPDFPixmap(gro->imobjno+1, -1, p->data.image, 8); } break; case GL2PS_TEXT: gl2ps->xreflist[gro->fontobjno] = offs; offs += gl2psPrintPDFText(gro->fontobjno,p->data.text,gro->fontno); break; case GL2PS_SPECIAL : /* alignment contains the format for which the special output text is intended */ if (p->data.text->alignment == GL2PS_PDF) { offs += fprintf(gl2ps->stream, "%s\n", p->data.text->str); } break; default: break; } } return offs; } /* All variable data has been written at this point and all required functioninality has been gathered, so we can write now file footer with cross reference table and trailer */ static void gl2psPrintPDFFooter(void) { int i; size_t offs; gl2psPDFgroupListInit(); gl2psPDFgroupListWriteMainStream(); offs = gl2ps->xreflist[5] + gl2ps->streamlength; offs += gl2psClosePDFDataStream(); gl2ps->xreflist[5] = offs; offs += gl2psPrintPDFDataStreamLength(gl2ps->streamlength); gl2ps->xreflist[6] = offs; gl2ps->streamlength = 0; offs += gl2psPrintPDFOpenPage(); offs += gl2psPDFgroupListWriteVariableResources(); gl2ps->xreflist = (size_t*)gl2psRealloc(gl2ps->xreflist, sizeof(size_t) * (gl2ps->objects_stack + 1)); gl2ps->xreflist[7] = offs; offs += gl2psPrintPDFGSObject(); gl2ps->xreflist[8] = offs; gl2ps->xreflist[gl2ps->objects_stack] = gl2psPDFgroupListWriteObjects(gl2ps->xreflist[8]); /* Start cross reference table. The file has to been opened in binary mode to preserve the 20 digit string length! */ fprintf(gl2ps->stream, "xref\n" "0 %d\n" "%010d 65535 f \n", gl2ps->objects_stack, 0); for (i = 1; i < gl2ps->objects_stack; ++i) { fprintf(gl2ps->stream, "%010zu 00000 n \n", gl2ps->xreflist[i]); } fprintf(gl2ps->stream, "trailer\n" "<<\n" "/Size %d\n" "/Info 1 0 R\n" "/Root 2 0 R\n" ">>\n" "startxref\n%zu\n" "%%%%EOF\n", gl2ps->objects_stack, gl2ps->xreflist[gl2ps->objects_stack]); /* Free auxiliary lists and arrays */ gl2psFree(gl2ps->xreflist); gl2psListAction(gl2ps->pdfprimlist, gl2psFreePrimitive); gl2psListDelete(gl2ps->pdfprimlist); gl2psPDFgroupListDelete(); #if defined(GL2PS_HAVE_ZLIB) if (gl2ps->options & GL2PS_COMPRESS) { gl2psFreeCompress(); gl2psFree(gl2ps->compress); gl2ps->compress = NULL; } #endif } /* PDF begin viewport */ static void gl2psPrintPDFBeginViewport(GLint viewport[4]) { int offs = 0; GLint index; GLfloat rgba[4]; int x = viewport[0], y = viewport[1], w = viewport[2], h = viewport[3]; glRenderMode(GL_FEEDBACK); if (gl2ps->header) { gl2psPrintPDFHeader(); gl2ps->header = GL_FALSE; } offs += gl2psPrintf("q\n"); if (gl2ps->options & GL2PS_DRAW_BACKGROUND) { if (gl2ps->colormode == GL_RGBA || gl2ps->colorsize == 0) { glGetFloatv(GL_COLOR_CLEAR_VALUE, rgba); } else { glGetIntegerv(GL_INDEX_CLEAR_VALUE, &index); rgba[0] = gl2ps->colormap[index][0]; rgba[1] = gl2ps->colormap[index][1]; rgba[2] = gl2ps->colormap[index][2]; rgba[3] = 1.0F; } offs += gl2psPrintPDFFillColor(rgba); offs += gl2psPrintf("%d %d %d %d re\n" "W\n" "f\n", x, y, w, h); } else { offs += gl2psPrintf("%d %d %d %d re\n" "W\n" "n\n", x, y, w, h); } gl2ps->streamlength += offs; } static GLint gl2psPrintPDFEndViewport(void) { GLint res; res = gl2psPrintPrimitives(); gl2ps->streamlength += gl2psPrintf("Q\n"); return res; } static void gl2psPrintPDFFinalPrimitive(void) { } /* definition of the PDF backend */ static GL2PSbackend gl2psPDF = { gl2psPrintPDFHeader, gl2psPrintPDFFooter, gl2psPrintPDFBeginViewport, gl2psPrintPDFEndViewport, gl2psPrintPDFPrimitive, gl2psPrintPDFFinalPrimitive, "pdf", "Portable Document Format" }; /********************************************************************* * * SVG routines * *********************************************************************/ static void gl2psSVGGetCoordsAndColors(int n, GL2PSvertex* verts, GL2PSxyz* xyz, GL2PSrgba* rgba) { int i, j; for (i = 0; i < n; i++) { xyz[i][0] = verts[i].xyz[0]; xyz[i][1] = gl2ps->viewport[3] - verts[i].xyz[1]; xyz[i][2] = 0.0F; for (j = 0; j < 4; j++) { rgba[i][j] = verts[i].rgba[j]; } } } static void gl2psSVGGetColorString(GL2PSrgba rgba, char str[32]) { int r = (int)(255. * rgba[0]); int g = (int)(255. * rgba[1]); int b = (int)(255. * rgba[2]); int rc = (r < 0) ? 0 : (r > 255) ? 255 : r; int gc = (g < 0) ? 0 : (g > 255) ? 255 : g; int bc = (b < 0) ? 0 : (b > 255) ? 255 : b; sprintf(str, "#%2.2x%2.2x%2.2x", rc, gc, bc); } static void gl2psPrintSVGHeader(void) { int x, y, width, height; char col[32]; time_t now; time(&now); if (gl2ps->options & GL2PS_LANDSCAPE) { x = (int)gl2ps->viewport[1]; y = (int)gl2ps->viewport[0]; width = (int)gl2ps->viewport[3]; height = (int)gl2ps->viewport[2]; } else { x = (int)gl2ps->viewport[0]; y = (int)gl2ps->viewport[1]; width = (int)gl2ps->viewport[2]; height = (int)gl2ps->viewport[3]; } /* Compressed SVG files (.svgz) are simply gzipped SVG files */ gl2psPrintGzipHeader(); gl2psPrintf("\n"); gl2psPrintf("\n", width, height, x, y, width, height); gl2psPrintf("%s\n", gl2ps->title); gl2psPrintf("\n"); gl2psPrintf("Creator: GL2PS %d.%d.%d%s, %s\n" "For: %s\n" "CreationDate: %s", GL2PS_MAJOR_VERSION, GL2PS_MINOR_VERSION, GL2PS_PATCH_VERSION, GL2PS_EXTRA_VERSION, GL2PS_COPYRIGHT, gl2ps->producer, ctime(&now)); gl2psPrintf("\n"); gl2psPrintf("\n"); gl2psPrintf("\n"); if (gl2ps->options & GL2PS_DRAW_BACKGROUND) { gl2psSVGGetColorString(gl2ps->bgcolor, col); gl2psPrintf("\n", col, (int)gl2ps->viewport[0], (int)gl2ps->viewport[1], (int)gl2ps->viewport[2], (int)gl2ps->viewport[1], (int)gl2ps->viewport[2], (int)gl2ps->viewport[3], (int)gl2ps->viewport[0], (int)gl2ps->viewport[3]); } /* group all the primitives and disable antialiasing */ gl2psPrintf("\n"); } static void gl2psPrintSVGSmoothTriangle(GL2PSxyz xyz[3], GL2PSrgba rgba[3]) { int i; GL2PSxyz xyz2[3]; GL2PSrgba rgba2[3]; char col[32]; /* Apparently there is no easy way to do Gouraud shading in SVG without explicitly pre-defining gradients, so for now we just do recursive subdivision */ if (gl2psSameColorThreshold(3, rgba, gl2ps->threshold)) { gl2psSVGGetColorString(rgba[0], col); gl2psPrintf("\n", xyz[0][0], xyz[0][1], xyz[1][0], xyz[1][1], xyz[2][0], xyz[2][1]); } else { /* subdivide into 4 subtriangles */ for (i = 0; i < 3; i++) { xyz2[0][i] = xyz[0][i]; xyz2[1][i] = 0.5F * (xyz[0][i] + xyz[1][i]); xyz2[2][i] = 0.5F * (xyz[0][i] + xyz[2][i]); } for (i = 0; i < 4; i++) { rgba2[0][i] = rgba[0][i]; rgba2[1][i] = 0.5F * (rgba[0][i] + rgba[1][i]); rgba2[2][i] = 0.5F * (rgba[0][i] + rgba[2][i]); } gl2psPrintSVGSmoothTriangle(xyz2, rgba2); for (i = 0; i < 3; i++) { xyz2[0][i] = 0.5F * (xyz[0][i] + xyz[1][i]); xyz2[1][i] = xyz[1][i]; xyz2[2][i] = 0.5F * (xyz[1][i] + xyz[2][i]); } for (i = 0; i < 4; i++) { rgba2[0][i] = 0.5F * (rgba[0][i] + rgba[1][i]); rgba2[1][i] = rgba[1][i]; rgba2[2][i] = 0.5F * (rgba[1][i] + rgba[2][i]); } gl2psPrintSVGSmoothTriangle(xyz2, rgba2); for (i = 0; i < 3; i++) { xyz2[0][i] = 0.5F * (xyz[0][i] + xyz[2][i]); xyz2[1][i] = xyz[2][i]; xyz2[2][i] = 0.5F * (xyz[1][i] + xyz[2][i]); } for (i = 0; i < 4; i++) { rgba2[0][i] = 0.5F * (rgba[0][i] + rgba[2][i]); rgba2[1][i] = rgba[2][i]; rgba2[2][i] = 0.5F * (rgba[1][i] + rgba[2][i]); } gl2psPrintSVGSmoothTriangle(xyz2, rgba2); for (i = 0; i < 3; i++) { xyz2[0][i] = 0.5F * (xyz[0][i] + xyz[1][i]); xyz2[1][i] = 0.5F * (xyz[1][i] + xyz[2][i]); xyz2[2][i] = 0.5F * (xyz[0][i] + xyz[2][i]); } for (i = 0; i < 4; i++) { rgba2[0][i] = 0.5F * (rgba[0][i] + rgba[1][i]); rgba2[1][i] = 0.5F * (rgba[1][i] + rgba[2][i]); rgba2[2][i] = 0.5F * (rgba[0][i] + rgba[2][i]); } gl2psPrintSVGSmoothTriangle(xyz2, rgba2); } } static void gl2psPrintSVGDash(GLushort pattern, GLint factor) { int i, n, array[10]; if (!pattern || !factor) { return; /* solid line */ } gl2psParseStipplePattern(pattern, factor, &n, array); gl2psPrintf("stroke-dasharray=\""); for (i = 0; i < n; i++) { if (i) { gl2psPrintf(","); } gl2psPrintf("%d", array[i]); } gl2psPrintf("\" "); } static void gl2psEndSVGLine(void) { int i; if (gl2ps->lastvertex.rgba[0] >= 0.) { gl2psPrintf("%g,%g\"/>\n", gl2ps->lastvertex.xyz[0], gl2ps->viewport[3] - gl2ps->lastvertex.xyz[1]); for (i = 0; i < 3; i++) { gl2ps->lastvertex.xyz[i] = -1.; } for (i = 0; i < 4; i++) { gl2ps->lastvertex.rgba[i] = -1.; } } } static void gl2psPrintSVGPixmap(GLfloat x, GLfloat y, GL2PSimage* pixmap) { #if defined(GL2PS_HAVE_LIBPNG) GL2PSlist* png; unsigned char c; int i; /* The only image types supported by the SVG standard are JPEG, PNG and SVG. Here we choose PNG, and since we want to embed the image directly in the SVG stream (and not link to an external image file), we need to encode the pixmap into PNG in memory, then encode it into base64. */ png = gl2psListCreate(pixmap->width * pixmap->height * 3, 1000, sizeof(unsigned char)); gl2psConvertPixmapToPNG(pixmap, png); gl2psListEncodeBase64(png); gl2psPrintf("height, pixmap->width, pixmap->height); gl2psPrintf("xlink:href=\"data:image/png;base64,"); for (i = 0; i < gl2psListNbr(png); i++) { gl2psListRead(png, i, &c); gl2psPrintf("%c", c); } gl2psPrintf("\"/>\n"); gl2psListDelete(png); #else gl2psMsg(GL2PS_WARNING, "GL2PS must be compiled with PNG support in " "order to embed images in SVG streams"); /* Harmless trick that prevents compiler warning if not GL2PS_HAVE_LIBPNG */ if (pixmap != NULL) { (void)(x); (void)(y); } #endif } static void gl2psPrintSVGPrimitive(void* data) { GL2PSprimitive* prim; GL2PSxyz xyz[4]; GL2PSrgba rgba[4]; char col[32]; int newline; prim = *(GL2PSprimitive**)data; if ((gl2ps->options & GL2PS_OCCLUSION_CULL) && prim->culled) { return; } /* We try to draw connected lines as a single path to get nice line joins and correct stippling. So if the primitive to print is not a line we must first finish the current line (if any): */ if (prim->type != GL2PS_LINE) { gl2psEndSVGLine(); } gl2psSVGGetCoordsAndColors(prim->numverts, prim->verts, xyz, rgba); switch (prim->type) { case GL2PS_POINT : gl2psSVGGetColorString(rgba[0], col); gl2psPrintf("\n", xyz[0][0], xyz[0][1], 0.5 * prim->width); break; case GL2PS_LINE : if (!gl2psSamePosition(gl2ps->lastvertex.xyz, prim->verts[0].xyz) || !gl2psSameColor(gl2ps->lastrgba, prim->verts[0].rgba) || gl2ps->lastlinewidth != prim->width || gl2ps->lastpattern != prim->pattern || gl2ps->lastfactor != prim->factor) { /* End the current line if the new segment does not start where the last one ended, or if the color, the width or the stippling have changed (we will need to use multi-point gradients for smooth-shaded lines) */ gl2psEndSVGLine(); newline = 1; } else { newline = 0; } gl2ps->lastvertex = prim->verts[1]; gl2psSetLastColor(prim->verts[0].rgba); gl2ps->lastlinewidth = prim->width; gl2ps->lastpattern = prim->pattern; gl2ps->lastfactor = prim->factor; if (newline) { gl2psSVGGetColorString(rgba[0], col); gl2psPrintf("width); if (rgba[0][3] < 1.0F) { gl2psPrintf("stroke-opacity=\"%g\" ", rgba[0][3]); } gl2psPrintSVGDash(prim->pattern, prim->factor); gl2psPrintf("points=\"%g,%g ", xyz[0][0], xyz[0][1]); } else { gl2psPrintf("%g,%g ", xyz[0][0], xyz[0][1]); } break; case GL2PS_TRIANGLE : gl2psPrintSVGSmoothTriangle(xyz, rgba); break; case GL2PS_QUADRANGLE : gl2psMsg(GL2PS_WARNING, "There should not be any quad left to print"); break; case GL2PS_PIXMAP : gl2psPrintSVGPixmap(xyz[0][0], xyz[0][1], prim->data.image); break; case GL2PS_TEXT : gl2psSVGGetColorString(prim->verts[0].rgba, col); gl2psPrintf("data.text->fontsize); if (prim->data.text->angle) gl2psPrintf("transform=\"rotate(%g, %g, %g)\" ", -prim->data.text->angle, xyz[0][0], xyz[0][1]); if (!strcmp(prim->data.text->fontname, "Times-Roman")) { gl2psPrintf("font-family=\"Times\">"); } else if (!strcmp(prim->data.text->fontname, "Times-Bold")) { gl2psPrintf("font-family=\"Times\" font-weight=\"bold\">"); } else if (!strcmp(prim->data.text->fontname, "Times-Italic")) { gl2psPrintf("font-family=\"Times\" font-style=\"italic\">"); } else if (!strcmp(prim->data.text->fontname, "Times-BoldItalic")) { gl2psPrintf("font-family=\"Times\" font-style=\"italic\" font-weight=\"bold\">"); } else if (!strcmp(prim->data.text->fontname, "Helvetica-Bold")) { gl2psPrintf("font-family=\"Helvetica\" font-weight=\"bold\">"); } else if (!strcmp(prim->data.text->fontname, "Helvetica-Oblique")) { gl2psPrintf("font-family=\"Helvetica\" font-style=\"oblique\">"); } else if (!strcmp(prim->data.text->fontname, "Helvetica-BoldOblique")) { gl2psPrintf("font-family=\"Helvetica\" font-style=\"oblique\" font-weight=\"bold\">"); } else if (!strcmp(prim->data.text->fontname, "Courier-Bold")) { gl2psPrintf("font-family=\"Courier\" font-weight=\"bold\">"); } else if (!strcmp(prim->data.text->fontname, "Courier-Oblique")) { gl2psPrintf("font-family=\"Courier\" font-style=\"oblique\">"); } else if (!strcmp(prim->data.text->fontname, "Courier-BoldOblique")) { gl2psPrintf("font-family=\"Courier\" font-style=\"oblique\" font-weight=\"bold\">"); } else { gl2psPrintf("font-family=\"%s\">", prim->data.text->fontname); } gl2psPrintf("%s\n", prim->data.text->str); break; case GL2PS_SPECIAL : /* alignment contains the format for which the special output text is intended */ if (prim->data.text->alignment == GL2PS_SVG) { gl2psPrintf("%s\n", prim->data.text->str); } break; default : break; } } static void gl2psPrintSVGFooter(void) { gl2psPrintf("\n"); gl2psPrintf("\n"); gl2psPrintGzipFooter(); } static void gl2psPrintSVGBeginViewport(GLint viewport[4]) { GLint index; char col[32]; GLfloat rgba[4]; int x = viewport[0], y = viewport[1], w = viewport[2], h = viewport[3]; glRenderMode(GL_FEEDBACK); if (gl2ps->header) { gl2psPrintSVGHeader(); gl2ps->header = GL_FALSE; } if (gl2ps->options & GL2PS_DRAW_BACKGROUND) { if (gl2ps->colormode == GL_RGBA || gl2ps->colorsize == 0) { glGetFloatv(GL_COLOR_CLEAR_VALUE, rgba); } else { glGetIntegerv(GL_INDEX_CLEAR_VALUE, &index); rgba[0] = gl2ps->colormap[index][0]; rgba[1] = gl2ps->colormap[index][1]; rgba[2] = gl2ps->colormap[index][2]; rgba[3] = 1.0F; } gl2psSVGGetColorString(rgba, col); gl2psPrintf("\n", col, x, gl2ps->viewport[3] - y, x + w, gl2ps->viewport[3] - y, x + w, gl2ps->viewport[3] - (y + h), x, gl2ps->viewport[3] - (y + h)); } gl2psPrintf("\n", x, y, w, h); gl2psPrintf(" \n", x, gl2ps->viewport[3] - y, x + w, gl2ps->viewport[3] - y, x + w, gl2ps->viewport[3] - (y + h), x, gl2ps->viewport[3] - (y + h)); gl2psPrintf("\n"); gl2psPrintf("\n", x, y, w, h); } static GLint gl2psPrintSVGEndViewport(void) { GLint res; res = gl2psPrintPrimitives(); gl2psPrintf("\n"); return res; } static void gl2psPrintSVGFinalPrimitive(void) { /* End any remaining line, if any */ gl2psEndSVGLine(); } /* definition of the SVG backend */ static GL2PSbackend gl2psSVG = { gl2psPrintSVGHeader, gl2psPrintSVGFooter, gl2psPrintSVGBeginViewport, gl2psPrintSVGEndViewport, gl2psPrintSVGPrimitive, gl2psPrintSVGFinalPrimitive, "svg", "Scalable Vector Graphics" }; /********************************************************************* * * PGF routines * *********************************************************************/ static void gl2psPrintPGFColor(GL2PSrgba rgba) { if (!gl2psSameColor(gl2ps->lastrgba, rgba)) { gl2psSetLastColor(rgba); fprintf(gl2ps->stream, "\\color[rgb]{%f,%f,%f}\n", rgba[0], rgba[1], rgba[2]); } } static void gl2psPrintPGFHeader(void) { time_t now; time(&now); fprintf(gl2ps->stream, "%% Title: %s\n" "%% Creator: GL2PS %d.%d.%d%s, %s\n" "%% For: %s\n" "%% CreationDate: %s", gl2ps->title, GL2PS_MAJOR_VERSION, GL2PS_MINOR_VERSION, GL2PS_PATCH_VERSION, GL2PS_EXTRA_VERSION, GL2PS_COPYRIGHT, gl2ps->producer, ctime(&now)); fprintf(gl2ps->stream, "\\begin{pgfpicture}\n"); if (gl2ps->options & GL2PS_DRAW_BACKGROUND) { gl2psPrintPGFColor(gl2ps->bgcolor); fprintf(gl2ps->stream, "\\pgfpathrectanglecorners{" "\\pgfpoint{%dpt}{%dpt}}{\\pgfpoint{%dpt}{%dpt}}\n" "\\pgfusepath{fill}\n", (int)gl2ps->viewport[0], (int)gl2ps->viewport[1], (int)gl2ps->viewport[2], (int)gl2ps->viewport[3]); } } static void gl2psPrintPGFDash(GLushort pattern, GLint factor) { int i, n, array[10]; if (pattern == gl2ps->lastpattern && factor == gl2ps->lastfactor) { return; } gl2ps->lastpattern = pattern; gl2ps->lastfactor = factor; if (!pattern || !factor) { /* solid line */ fprintf(gl2ps->stream, "\\pgfsetdash{}{0pt}\n"); } else { gl2psParseStipplePattern(pattern, factor, &n, array); fprintf(gl2ps->stream, "\\pgfsetdash{"); for (i = 0; i < n; i++) { fprintf(gl2ps->stream, "{%dpt}", array[i]); } fprintf(gl2ps->stream, "}{0pt}\n"); } } static const char* gl2psPGFTextAlignment(int align) { switch (align) { case GL2PS_TEXT_C : return "center"; case GL2PS_TEXT_CL : return "west"; case GL2PS_TEXT_CR : return "east"; case GL2PS_TEXT_B : return "south"; case GL2PS_TEXT_BR : return "south east"; case GL2PS_TEXT_T : return "north"; case GL2PS_TEXT_TL : return "north west"; case GL2PS_TEXT_TR : return "north east"; case GL2PS_TEXT_BL : default : return "south west"; } } static void gl2psPrintPGFPrimitive(void* data) { GL2PSprimitive* prim; prim = *(GL2PSprimitive**)data; switch (prim->type) { case GL2PS_POINT : /* Points in openGL are rectangular */ gl2psPrintPGFColor(prim->verts[0].rgba); fprintf(gl2ps->stream, "\\pgfpathrectangle{\\pgfpoint{%fpt}{%fpt}}" "{\\pgfpoint{%fpt}{%fpt}}\n\\pgfusepath{fill}\n", prim->verts[0].xyz[0]-0.5*prim->width, prim->verts[0].xyz[1]-0.5*prim->width, prim->width,prim->width); break; case GL2PS_LINE : gl2psPrintPGFColor(prim->verts[0].rgba); if (gl2ps->lastlinewidth != prim->width) { gl2ps->lastlinewidth = prim->width; fprintf(gl2ps->stream, "\\pgfsetlinewidth{%fpt}\n", gl2ps->lastlinewidth); } gl2psPrintPGFDash(prim->pattern, prim->factor); fprintf(gl2ps->stream, "\\pgfpathmoveto{\\pgfpoint{%fpt}{%fpt}}\n" "\\pgflineto{\\pgfpoint{%fpt}{%fpt}}\n" "\\pgfusepath{stroke}\n", prim->verts[1].xyz[0], prim->verts[1].xyz[1], prim->verts[0].xyz[0], prim->verts[0].xyz[1]); break; case GL2PS_TRIANGLE : if (gl2ps->lastlinewidth != 0) { gl2ps->lastlinewidth = 0; fprintf(gl2ps->stream, "\\pgfsetlinewidth{0.01pt}\n"); } gl2psPrintPGFColor(prim->verts[0].rgba); fprintf(gl2ps->stream, "\\pgfpathmoveto{\\pgfpoint{%fpt}{%fpt}}\n" "\\pgflineto{\\pgfpoint{%fpt}{%fpt}}\n" "\\pgflineto{\\pgfpoint{%fpt}{%fpt}}\n" "\\pgfpathclose\n" "\\pgfusepath{fill,stroke}\n", prim->verts[2].xyz[0], prim->verts[2].xyz[1], prim->verts[1].xyz[0], prim->verts[1].xyz[1], prim->verts[0].xyz[0], prim->verts[0].xyz[1]); break; case GL2PS_TEXT : fprintf(gl2ps->stream, "{\n\\pgftransformshift{\\pgfpoint{%fpt}{%fpt}}\n", prim->verts[0].xyz[0], prim->verts[0].xyz[1]); if (prim->data.text->angle) { fprintf(gl2ps->stream, "\\pgftransformrotate{%f}{", prim->data.text->angle); } fprintf(gl2ps->stream, "\\pgfnode{rectangle}{%s}{\\fontsize{%d}{0}\\selectfont", gl2psPGFTextAlignment(prim->data.text->alignment), prim->data.text->fontsize); fprintf(gl2ps->stream, "\\textcolor[rgb]{%g,%g,%g}{{%s}}", prim->verts[0].rgba[0], prim->verts[0].rgba[1], prim->verts[0].rgba[2], prim->data.text->str); fprintf(gl2ps->stream, "}{}{\\pgfusepath{discard}}}\n"); break; case GL2PS_SPECIAL : /* alignment contains the format for which the special output text is intended */ if (prim->data.text->alignment == GL2PS_PGF) { fprintf(gl2ps->stream, "%s\n", prim->data.text->str); } break; default : break; } } static void gl2psPrintPGFFooter(void) { fprintf(gl2ps->stream, "\\end{pgfpicture}\n"); } static void gl2psPrintPGFBeginViewport(GLint viewport[4]) { GLint index; GLfloat rgba[4]; int x = viewport[0], y = viewport[1], w = viewport[2], h = viewport[3]; glRenderMode(GL_FEEDBACK); if (gl2ps->header) { gl2psPrintPGFHeader(); gl2ps->header = GL_FALSE; } fprintf(gl2ps->stream, "\\begin{pgfscope}\n"); if (gl2ps->options & GL2PS_DRAW_BACKGROUND) { if (gl2ps->colormode == GL_RGBA || gl2ps->colorsize == 0) { glGetFloatv(GL_COLOR_CLEAR_VALUE, rgba); } else { glGetIntegerv(GL_INDEX_CLEAR_VALUE, &index); rgba[0] = gl2ps->colormap[index][0]; rgba[1] = gl2ps->colormap[index][1]; rgba[2] = gl2ps->colormap[index][2]; rgba[3] = 1.0F; } gl2psPrintPGFColor(rgba); fprintf(gl2ps->stream, "\\pgfpathrectangle{\\pgfpoint{%dpt}{%dpt}}" "{\\pgfpoint{%dpt}{%dpt}}\n" "\\pgfusepath{fill}\n", x, y, w, h); } fprintf(gl2ps->stream, "\\pgfpathrectangle{\\pgfpoint{%dpt}{%dpt}}" "{\\pgfpoint{%dpt}{%dpt}}\n" "\\pgfusepath{clip}\n", x, y, w, h); } static GLint gl2psPrintPGFEndViewport(void) { GLint res; res = gl2psPrintPrimitives(); fprintf(gl2ps->stream, "\\end{pgfscope}\n"); return res; } static void gl2psPrintPGFFinalPrimitive(void) { } /* definition of the PGF backend */ static GL2PSbackend gl2psPGF = { gl2psPrintPGFHeader, gl2psPrintPGFFooter, gl2psPrintPGFBeginViewport, gl2psPrintPGFEndViewport, gl2psPrintPGFPrimitive, gl2psPrintPGFFinalPrimitive, "tex", "PGF Latex Graphics" }; /********************************************************************* * * General primitive printing routine * *********************************************************************/ /* Warning: the ordering of the backends must match the format #defines in gl2ps.h */ static GL2PSbackend* gl2psbackends[] = { &gl2psPS, /* 0 */ &gl2psEPS, /* 1 */ &gl2psTEX, /* 2 */ &gl2psPDF, /* 3 */ &gl2psSVG, /* 4 */ &gl2psPGF /* 5 */ }; static void gl2psComputeTightBoundingBox(void* data) { GL2PSprimitive* prim; int i; prim = *(GL2PSprimitive**)data; for (i = 0; i < prim->numverts; i++) { if (prim->verts[i].xyz[0] < gl2ps->viewport[0]) { gl2ps->viewport[0] = (GLint)prim->verts[i].xyz[0]; } if (prim->verts[i].xyz[0] > gl2ps->viewport[2]) { gl2ps->viewport[2] = (GLint)(prim->verts[i].xyz[0] + 0.5F); } if (prim->verts[i].xyz[1] < gl2ps->viewport[1]) { gl2ps->viewport[1] = (GLint)prim->verts[i].xyz[1]; } if (prim->verts[i].xyz[1] > gl2ps->viewport[3]) { gl2ps->viewport[3] = (GLint)(prim->verts[i].xyz[1] + 0.5F); } } } static GLint gl2psPrintPrimitives(void) { GL2PSbsptree* root; GL2PSxyz eye = {0.0F, 0.0F, 100.0F * GL2PS_ZSCALE}; GLint used; used = glRenderMode(GL_RENDER); if (used < 0) { gl2psMsg(GL2PS_INFO, "OpenGL feedback buffer overflow"); return GL2PS_OVERFLOW; } if (used > 0) { gl2psParseFeedbackBuffer(used); } gl2psRescaleAndOffset(); if (gl2ps->header) { if (gl2psListNbr(gl2ps->primitives) && (gl2ps->options & GL2PS_TIGHT_BOUNDING_BOX)) { gl2ps->viewport[0] = gl2ps->viewport[1] = 100000; gl2ps->viewport[2] = gl2ps->viewport[3] = -100000; gl2psListAction(gl2ps->primitives, gl2psComputeTightBoundingBox); } (gl2psbackends[gl2ps->format]->printHeader)(); gl2ps->header = GL_FALSE; } if (!gl2psListNbr(gl2ps->primitives)) { /* empty feedback buffer and/or nothing else to print */ return GL2PS_NO_FEEDBACK; } switch (gl2ps->sort) { case GL2PS_NO_SORT : gl2psListAction(gl2ps->primitives, gl2psbackends[gl2ps->format]->printPrimitive); gl2psListAction(gl2ps->primitives, gl2psFreePrimitive); /* reset the primitive list, waiting for the next viewport */ gl2psListReset(gl2ps->primitives); break; case GL2PS_SIMPLE_SORT : gl2psListSort(gl2ps->primitives, gl2psCompareDepth); if (gl2ps->options & GL2PS_OCCLUSION_CULL) { gl2psListActionInverse(gl2ps->primitives, gl2psAddInImageTree); gl2psFreeBspImageTree(&gl2ps->imagetree); } gl2psListAction(gl2ps->primitives, gl2psbackends[gl2ps->format]->printPrimitive); gl2psListAction(gl2ps->primitives, gl2psFreePrimitive); /* reset the primitive list, waiting for the next viewport */ gl2psListReset(gl2ps->primitives); break; case GL2PS_BSP_SORT : root = (GL2PSbsptree*)gl2psMalloc(sizeof(GL2PSbsptree)); gl2psBuildBspTree(root, gl2ps->primitives); if (GL_TRUE == gl2ps->boundary) { gl2psBuildPolygonBoundary(root); } if (gl2ps->options & GL2PS_OCCLUSION_CULL) { gl2psTraverseBspTree(root, eye, -GL2PS_EPSILON, gl2psLess, gl2psAddInImageTree, 1); gl2psFreeBspImageTree(&gl2ps->imagetree); } gl2psTraverseBspTree(root, eye, GL2PS_EPSILON, gl2psGreater, gl2psbackends[gl2ps->format]->printPrimitive, 0); gl2psFreeBspTree(&root); /* reallocate the primitive list (it's been deleted by gl2psBuildBspTree) in case there is another viewport */ gl2ps->primitives = gl2psListCreate(500, 500, sizeof(GL2PSprimitive*)); break; } gl2psbackends[gl2ps->format]->printFinalPrimitive(); return GL2PS_SUCCESS; } /********************************************************************* * * Public routines * *********************************************************************/ GL2PSDLL_API GLint gl2psBeginPage(const char* title, const char* producer, GLint viewport[4], GLint format, GLint sort, GLint options, GLint colormode, GLint colorsize, GL2PSrgba* colormap, GLint nr, GLint ng, GLint nb, GLint buffersize, FILE* stream, const char* filename) { GLint index; int i; if (gl2ps) { gl2psMsg(GL2PS_ERROR, "gl2psBeginPage called in wrong program state"); return GL2PS_ERROR; } gl2ps = (GL2PScontext*)gl2psMalloc(sizeof(GL2PScontext)); if (format >= 0 && format < (GLint)(sizeof(gl2psbackends) / sizeof(gl2psbackends[0]))) { gl2ps->format = format; } else { gl2psMsg(GL2PS_ERROR, "Unknown output format: %d", format); gl2psFree(gl2ps); gl2ps = NULL; return GL2PS_ERROR; } switch (sort) { case GL2PS_NO_SORT : case GL2PS_SIMPLE_SORT : case GL2PS_BSP_SORT : gl2ps->sort = sort; break; default : gl2psMsg(GL2PS_ERROR, "Unknown sorting algorithm: %d", sort); gl2psFree(gl2ps); gl2ps = NULL; return GL2PS_ERROR; } if (stream) { gl2ps->stream = stream; } else { gl2psMsg(GL2PS_ERROR, "Bad file pointer"); gl2psFree(gl2ps); gl2ps = NULL; return GL2PS_ERROR; } gl2ps->header = GL_TRUE; gl2ps->maxbestroot = 10; gl2ps->options = options; gl2ps->compress = NULL; gl2ps->imagemap_head = NULL; gl2ps->imagemap_tail = NULL; if (gl2ps->options & GL2PS_USE_CURRENT_VIEWPORT) { glGetIntegerv(GL_VIEWPORT, gl2ps->viewport); } else { for (i = 0; i < 4; i++) { gl2ps->viewport[i] = viewport[i]; } } if (!gl2ps->viewport[2] || !gl2ps->viewport[3]) { gl2psMsg(GL2PS_ERROR, "Incorrect viewport (x=%d, y=%d, width=%d, height=%d)", gl2ps->viewport[0], gl2ps->viewport[1], gl2ps->viewport[2], gl2ps->viewport[3]); gl2psFree(gl2ps); gl2ps = NULL; return GL2PS_ERROR; } gl2ps->threshold[0] = nr ? 1.0F / (GLfloat)nr : 0.064F; gl2ps->threshold[1] = ng ? 1.0F / (GLfloat)ng : 0.034F; gl2ps->threshold[2] = nb ? 1.0F / (GLfloat)nb : 0.100F; gl2ps->colormode = colormode; gl2ps->buffersize = buffersize > 0 ? buffersize : 2048 * 2048; for (i = 0; i < 3; i++) { gl2ps->lastvertex.xyz[i] = -1.0F; } for (i = 0; i < 4; i++) { gl2ps->lastvertex.rgba[i] = -1.0F; gl2ps->lastrgba[i] = -1.0F; } gl2ps->lastlinewidth = -1.0F; gl2ps->lastpattern = 0; gl2ps->lastfactor = 0; gl2ps->imagetree = NULL; gl2ps->primitivetoadd = NULL; gl2ps->zerosurfacearea = GL_FALSE; gl2ps->pdfprimlist = NULL; gl2ps->pdfgrouplist = NULL; gl2ps->xreflist = NULL; /* get default blending mode from current OpenGL state (enabled by default for SVG) */ gl2ps->blending = (gl2ps->format == GL2PS_SVG) ? GL_TRUE : glIsEnabled(GL_BLEND); glGetIntegerv(GL_BLEND_SRC, &gl2ps->blendfunc[0]); glGetIntegerv(GL_BLEND_DST, &gl2ps->blendfunc[1]); if (gl2ps->colormode == GL_RGBA) { gl2ps->colorsize = 0; gl2ps->colormap = NULL; glGetFloatv(GL_COLOR_CLEAR_VALUE, gl2ps->bgcolor); } else if (gl2ps->colormode == GL_COLOR_INDEX) { if (!colorsize || !colormap) { gl2psMsg(GL2PS_ERROR, "Missing colormap for GL_COLOR_INDEX rendering"); gl2psFree(gl2ps); gl2ps = NULL; return GL2PS_ERROR; } gl2ps->colorsize = colorsize; gl2ps->colormap = (GL2PSrgba*)gl2psMalloc(gl2ps->colorsize * sizeof(GL2PSrgba)); memcpy(gl2ps->colormap, colormap, gl2ps->colorsize * sizeof(GL2PSrgba)); glGetIntegerv(GL_INDEX_CLEAR_VALUE, &index); gl2ps->bgcolor[0] = gl2ps->colormap[index][0]; gl2ps->bgcolor[1] = gl2ps->colormap[index][1]; gl2ps->bgcolor[2] = gl2ps->colormap[index][2]; gl2ps->bgcolor[3] = 1.0F; } else { gl2psMsg(GL2PS_ERROR, "Unknown color mode in gl2psBeginPage"); gl2psFree(gl2ps); gl2ps = NULL; return GL2PS_ERROR; } if (!title) { gl2ps->title = (char*)gl2psMalloc(sizeof(char)); gl2ps->title[0] = '\0'; } else { gl2ps->title = (char*)gl2psMalloc((strlen(title)+1)*sizeof(char)); strcpy(gl2ps->title, title); } if (!producer) { gl2ps->producer = (char*)gl2psMalloc(sizeof(char)); gl2ps->producer[0] = '\0'; } else { gl2ps->producer = (char*)gl2psMalloc((strlen(producer)+1)*sizeof(char)); strcpy(gl2ps->producer, producer); } if (!filename) { gl2ps->filename = (char*)gl2psMalloc(sizeof(char)); gl2ps->filename[0] = '\0'; } else { gl2ps->filename = (char*)gl2psMalloc((strlen(filename)+1)*sizeof(char)); strcpy(gl2ps->filename, filename); } gl2ps->primitives = gl2psListCreate(500, 500, sizeof(GL2PSprimitive*)); gl2ps->auxprimitives = gl2psListCreate(100, 100, sizeof(GL2PSprimitive*)); gl2ps->feedback = (GLfloat*)gl2psMalloc(gl2ps->buffersize * sizeof(GLfloat)); glFeedbackBuffer(gl2ps->buffersize, GL_3D_COLOR, gl2ps->feedback); glRenderMode(GL_FEEDBACK); return GL2PS_SUCCESS; } GL2PSDLL_API GLint gl2psEndPage(void) { GLint res; if (!gl2ps) { return GL2PS_UNINITIALIZED; } res = gl2psPrintPrimitives(); if (res != GL2PS_OVERFLOW) { (gl2psbackends[gl2ps->format]->printFooter)(); } fflush(gl2ps->stream); gl2psListDelete(gl2ps->primitives); gl2psListDelete(gl2ps->auxprimitives); gl2psFreeImagemap(gl2ps->imagemap_head); gl2psFree(gl2ps->colormap); gl2psFree(gl2ps->title); gl2psFree(gl2ps->producer); gl2psFree(gl2ps->filename); gl2psFree(gl2ps->feedback); gl2psFree(gl2ps); gl2ps = NULL; return res; } GL2PSDLL_API GLint gl2psBeginViewport(GLint viewport[4]) { if (!gl2ps) { return GL2PS_UNINITIALIZED; } (gl2psbackends[gl2ps->format]->beginViewport)(viewport); return GL2PS_SUCCESS; } GL2PSDLL_API GLint gl2psEndViewport(void) { GLint res; if (!gl2ps) { return GL2PS_UNINITIALIZED; } res = (gl2psbackends[gl2ps->format]->endViewport)(); /* reset last used colors, line widths */ gl2ps->lastlinewidth = -1.0F; return res; } GL2PSDLL_API GLint gl2psTextOpt(const char* str, const char* fontname, GLshort fontsize, GLint alignment, GLfloat angle) { return gl2psAddText(GL2PS_TEXT, str, fontname, fontsize, alignment, angle); } GL2PSDLL_API GLint gl2psText(const char* str, const char* fontname, GLshort fontsize) { return gl2psAddText(GL2PS_TEXT, str, fontname, fontsize, GL2PS_TEXT_BL, 0.0F); } GL2PSDLL_API GLint gl2psSpecial(GLint format, const char* str) { return gl2psAddText(GL2PS_SPECIAL, str, "", 0, format, 0.0F); } GL2PSDLL_API GLint gl2psDrawPixels(GLsizei width, GLsizei height, GLint xorig, GLint yorig, GLenum format, GLenum type, const void* pixels) { int size, i; GLfloat pos[4], *piv; GL2PSprimitive* prim; GLboolean valid; if (!gl2ps || !pixels) { return GL2PS_UNINITIALIZED; } if ((width <= 0) || (height <= 0)) { return GL2PS_ERROR; } if (gl2ps->options & GL2PS_NO_PIXMAP) { return GL2PS_SUCCESS; } if ((format != GL_RGB && format != GL_RGBA) || type != GL_FLOAT) { gl2psMsg(GL2PS_ERROR, "gl2psDrawPixels only implemented for " "GL_RGB/GL_RGBA, GL_FLOAT pixels"); return GL2PS_ERROR; } glGetBooleanv(GL_CURRENT_RASTER_POSITION_VALID, &valid); if (GL_FALSE == valid) { return GL2PS_SUCCESS; /* the primitive is culled */ } glGetFloatv(GL_CURRENT_RASTER_POSITION, pos); prim = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive)); prim->type = GL2PS_PIXMAP; prim->boundary = 0; prim->numverts = 1; prim->verts = (GL2PSvertex*)gl2psMalloc(sizeof(GL2PSvertex)); prim->verts[0].xyz[0] = pos[0] + xorig; prim->verts[0].xyz[1] = pos[1] + yorig; prim->verts[0].xyz[2] = pos[2]; prim->culled = 0; prim->offset = 0; prim->pattern = 0; prim->factor = 0; prim->width = 1; glGetFloatv(GL_CURRENT_RASTER_COLOR, prim->verts[0].rgba); prim->data.image = (GL2PSimage*)gl2psMalloc(sizeof(GL2PSimage)); prim->data.image->width = width; prim->data.image->height = height; prim->data.image->format = format; prim->data.image->type = type; switch (format) { case GL_RGBA: if (gl2ps->options & GL2PS_NO_BLENDING || !gl2ps->blending) { /* special case: blending turned off */ prim->data.image->format = GL_RGB; size = height * width * 3; prim->data.image->pixels = (GLfloat*)gl2psMalloc(size * sizeof(GLfloat)); piv = (GLfloat*)pixels; for (i = 0; i < size; ++i, ++piv) { prim->data.image->pixels[i] = *piv; if (!((i+1)%3)) { ++piv; } } } else { size = height * width * 4; prim->data.image->pixels = (GLfloat*)gl2psMalloc(size * sizeof(GLfloat)); memcpy(prim->data.image->pixels, pixels, size * sizeof(GLfloat)); } break; case GL_RGB: default: size = height * width * 3; prim->data.image->pixels = (GLfloat*)gl2psMalloc(size * sizeof(GLfloat)); memcpy(prim->data.image->pixels, pixels, size * sizeof(GLfloat)); break; } gl2psListAdd(gl2ps->auxprimitives, &prim); glPassThrough(GL2PS_DRAW_PIXELS_TOKEN); return GL2PS_SUCCESS; } GL2PSDLL_API GLint gl2psDrawImageMap(GLsizei width, GLsizei height, const GLfloat position[3], const unsigned char* imagemap) { int size, i; int sizeoffloat = sizeof(GLfloat); if (!gl2ps || !imagemap) { return GL2PS_UNINITIALIZED; } if ((width <= 0) || (height <= 0)) { return GL2PS_ERROR; } size = height + height * ((width - 1) / 8); glPassThrough(GL2PS_IMAGEMAP_TOKEN); glBegin(GL_POINTS); glVertex3f(position[0], position[1],position[2]); glEnd(); glPassThrough((GLfloat)width); glPassThrough((GLfloat)height); for (i = 0; i < size; i += sizeoffloat) { float* value = (float*)imagemap; glPassThrough(*value); imagemap += sizeoffloat; } return GL2PS_SUCCESS; } GL2PSDLL_API GLint gl2psEnable(GLint mode) { GLint tmp; if (!gl2ps) { return GL2PS_UNINITIALIZED; } switch (mode) { case GL2PS_POLYGON_OFFSET_FILL : glPassThrough(GL2PS_BEGIN_OFFSET_TOKEN); glGetFloatv(GL_POLYGON_OFFSET_FACTOR, &gl2ps->offset[0]); glGetFloatv(GL_POLYGON_OFFSET_UNITS, &gl2ps->offset[1]); break; case GL2PS_POLYGON_BOUNDARY : glPassThrough(GL2PS_BEGIN_BOUNDARY_TOKEN); break; case GL2PS_LINE_STIPPLE : glPassThrough(GL2PS_BEGIN_STIPPLE_TOKEN); glGetIntegerv(GL_LINE_STIPPLE_PATTERN, &tmp); glPassThrough((GLfloat)tmp); glGetIntegerv(GL_LINE_STIPPLE_REPEAT, &tmp); glPassThrough((GLfloat)tmp); break; case GL2PS_BLEND : glPassThrough(GL2PS_BEGIN_BLEND_TOKEN); break; default : gl2psMsg(GL2PS_WARNING, "Unknown mode in gl2psEnable: %d", mode); return GL2PS_WARNING; } return GL2PS_SUCCESS; } GL2PSDLL_API GLint gl2psDisable(GLint mode) { if (!gl2ps) { return GL2PS_UNINITIALIZED; } switch (mode) { case GL2PS_POLYGON_OFFSET_FILL : glPassThrough(GL2PS_END_OFFSET_TOKEN); break; case GL2PS_POLYGON_BOUNDARY : glPassThrough(GL2PS_END_BOUNDARY_TOKEN); break; case GL2PS_LINE_STIPPLE : glPassThrough(GL2PS_END_STIPPLE_TOKEN); break; case GL2PS_BLEND : glPassThrough(GL2PS_END_BLEND_TOKEN); break; default : gl2psMsg(GL2PS_WARNING, "Unknown mode in gl2psDisable: %d", mode); return GL2PS_WARNING; } return GL2PS_SUCCESS; } GL2PSDLL_API GLint gl2psPointSize(GLfloat value) { if (!gl2ps) { return GL2PS_UNINITIALIZED; } glPassThrough(GL2PS_POINT_SIZE_TOKEN); glPassThrough(value); return GL2PS_SUCCESS; } GL2PSDLL_API GLint gl2psLineWidth(GLfloat value) { if (!gl2ps) { return GL2PS_UNINITIALIZED; } glPassThrough(GL2PS_LINE_WIDTH_TOKEN); glPassThrough(value); return GL2PS_SUCCESS; } GL2PSDLL_API GLint gl2psBlendFunc(GLenum sfactor, GLenum dfactor) { if (!gl2ps) { return GL2PS_UNINITIALIZED; } if (GL_FALSE == gl2psSupportedBlendMode(sfactor, dfactor)) { return GL2PS_WARNING; } glPassThrough(GL2PS_SRC_BLEND_TOKEN); glPassThrough((GLfloat)sfactor); glPassThrough(GL2PS_DST_BLEND_TOKEN); glPassThrough((GLfloat)dfactor); return GL2PS_SUCCESS; } GL2PSDLL_API GLint gl2psSetOptions(GLint options) { if (!gl2ps) { return GL2PS_UNINITIALIZED; } gl2ps->options = options; return GL2PS_SUCCESS; } GL2PSDLL_API GLint gl2psGetOptions(GLint* options) { if (!gl2ps) { *options = 0; return GL2PS_UNINITIALIZED; } *options = gl2ps->options; return GL2PS_SUCCESS; } GL2PSDLL_API const char* gl2psGetFileExtension(GLint format) { if (format >= 0 && format < (GLint)(sizeof(gl2psbackends) / sizeof(gl2psbackends[0]))) { return gl2psbackends[format]->file_extension; } else { return "Unknown format"; } } GL2PSDLL_API const char* gl2psGetFormatDescription(GLint format) { if (format >= 0 && format < (GLint)(sizeof(gl2psbackends) / sizeof(gl2psbackends[0]))) { return gl2psbackends[format]->description; } else { return "Unknown format"; } } mcrl2-201210.1/3rd-party/svc/include/svc/lz.h000664 001751 001751 00000003363 12042421220 021555 0ustar00jenkinsjenkins000000 000000 /* SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. $Id: lz.h,v 1.2 2008/09/30 08:22:51 bertl Exp $ */ #ifndef __LZ_H #define __LZ_H #include "mcrl2/aterm/aterm1.h" #include "code.h" #define SEARCH_BITS 15 #define LOOKAHEAD_BITS 8 #define SEARCHBUF_SIZE (256*128) #define LOOKAHEADBUF_SIZE 255 typedef unsigned char LZtoken[3]; /* CHANGED FROM 2 */ typedef struct { unsigned char search[SEARCHBUF_SIZE]; int last; int read, written; } LZbuffer; void LZinit(LZbuffer* buffer); int LZwriteATerm(BitStream* fp, LZbuffer* buffer, aterm::ATerm term); int LZreadATerm(BitStream* fp, LZbuffer* buffer, aterm::ATerm* term); int LZwriteString(BitStream* fp, LZbuffer* buffer, char* str); int LZreadString(BitStream* fp, LZbuffer* buffer, char** str); int LZwriteInt(BitStream* fp, LZbuffer* buffer, long n); int LZreadInt(BitStream* fp, LZbuffer* buffer, long* n); #endif mcrl2-201210.1/3rd-party/svc/include/svc/huffman.h000664 001751 001751 00000003164 12042421220 022553 0ustar00jenkinsjenkins000000 000000 /* SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. $Id: huffman.h,v 1.2 2008/09/30 08:22:51 bertl Exp $ */ #ifndef __HUFFMANHEADER #define __HUFFMANHEADER #include "hashtable.h" #include "blocklist.h" #include "lz.h" struct HFnode { struct HFnode* high, *low, *parent, *next, *previous; tBlock* block; unsigned long frequency; aterm::ATerm term; }; typedef struct { struct HFnode* codes, *top; HTable* terms; BList blockList; LZbuffer buffer; } HFtree; int HFinit(HFtree*, HTable*); void HFfree(HFtree*); int HFencodeATerm(BitStream*, HFtree*, aterm::ATerm); int HFencodeIndex(BitStream*, HFtree*, long); int HFdecodeATerm(BitStream*, HFtree*, aterm::ATerm*); int HFdecodeIndex(BitStream*, HFtree*, long*); #endif mcrl2-201210.1/3rd-party/svc/include/svc/hashtable.h000664 001751 001751 00000002630 12042421220 023057 0ustar00jenkinsjenkins000000 000000 /* SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. $Id: hashtable.h,v 1.2 2008/09/30 08:22:51 bertl Exp $ */ #ifndef __HASH_TABLE_H #define __HASH_TABLE_H #include "mcrl2/aterm/aterm2.h" #include "ptable.h" typedef struct { aterm::ATermIndexedSet terms; PTable pointers; } HTable; int HTinit(HTable*); void HTfree(HTable*); unsigned int HTinsert(HTable*, aterm::ATerm, void*); int HTmember(HTable*, aterm::ATerm, long*); aterm::ATerm HTgetTerm(HTable*, long); void* HTgetPtr(HTable*, long); void HTsetPtr(HTable*, long, void*); #endif mcrl2-201210.1/3rd-party/svc/include/svc/compress.h000664 001751 001751 00000004067 12042421220 022765 0ustar00jenkinsjenkins000000 000000 /* SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. $Id: compress.h,v 1.2 2008/09/30 08:22:51 bertl Exp $ */ #ifndef __COMPRESS_H #define __COMPRESS_H #include "huffman.h" typedef struct { BitStream* bs; HFtree tree; HTable* indices, deltas; long last, preLast; } CompressedStream; CompressedStream* CSinit(HTable*, BitStream*, int); void CSfree(CompressedStream*); int CSreadATerm(CompressedStream*, aterm::ATerm*); int CSreadIndex(CompressedStream*, aterm::ATerm*); int CSureadATerm(CompressedStream*, aterm::ATerm*); int CSreadString(CompressedStream*, char**); int CSureadString(CompressedStream*, char**); int CSreadInt(CompressedStream*, long*); int CSureadInt(CompressedStream*, long*); int CSwriteATerm(CompressedStream*, aterm::ATerm); int CSwriteIndex(CompressedStream*, aterm::ATerm); int CSuwriteATerm(CompressedStream*, aterm::ATerm); int CSwriteString(CompressedStream*, const char*); int CSuwriteString(CompressedStream*, const char*); int CSwriteInt(CompressedStream*, long); int CSuwriteInt(CompressedStream*, long); void CSflush(CompressedStream*); int CSseek(CompressedStream*, long, int); long CStell(CompressedStream*); #endif mcrl2-201210.1/3rd-party/svc/include/svc/svc1.h000664 001751 001751 00000006047 12042421220 022006 0ustar00jenkinsjenkins000000 000000 /* SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. $Id: svc1.h,v 1.3 2008/09/30 08:22:51 bertl Exp $ */ /* svc1.h: Header for svc level 1 interface */ #ifndef _SVC1_H #define _SVC1_H #include "mcrl2/aterm/aterm1.h" #include "compress.h" #include "string.h" #include #define SVC_VERSION "1.2 beta" typedef long SVCint; typedef enum {SVCfalse=0, SVCtrue } SVCbool; typedef enum {SVCwrite, SVCread } SVCfileMode; typedef struct { CompressedStream* csStates, *csLabels, *csParameters; BitStream* bs; SVCbool firstTransition, indexFlag; char* formatVersion; SVCfileMode fileMode; long headerPosition, bodyPosition, trailerPosition, versionPosition; HTable stateTable, labelTable, parameterTable; } ltsFile; struct ltsHeader { char* filename, /* filename */ *date, /* file creation date */ *version, /* file version */ *type, /* file subtype */ *creator, /* name of person or software */ *initialState, /* label of the initial state */ *comments; /* comments on the file */ long numStates, /* number of states in the system */ numTransitions,/* number of transitions in the system */ numLabels, numParameters; }; struct ltsTransition { aterm::ATerm fromState, /* label of source state */ toState, /* label of destination state */ label, /* label of transition */ parameters; /* parameters of the transition */ }; int svcInit(ltsFile*, char*, SVCfileMode, SVCbool*); int svcReadVersion(ltsFile*, char** version); int svcReadHeader(ltsFile*, struct ltsHeader*); int svcReadNextTransition(ltsFile*, struct ltsTransition*); int svcReadTrailer(ltsFile*); int svcWriteVersion(ltsFile*); int svcWriteHeader(ltsFile*, struct ltsHeader*); int svcWriteTransition(ltsFile*, struct ltsTransition*); int svcWriteTrailer(ltsFile*); int svcFree(ltsFile*); std::string svcError(int errnum); #endif mcrl2-201210.1/3rd-party/svc/include/svc/svcerrno.h000664 001751 001751 00000003145 12042421220 022767 0ustar00jenkinsjenkins000000 000000 /* SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. $Id: svcerrno.h,v 1.2 2008/09/30 08:22:51 bertl Exp $ */ #ifndef _SVCERRNO_H #define _SVCERRNO_H #include extern int SVCerrno; #define EACCESS 1 #define ENOINFO 10 #define EFORMATVERSION 11 #define ENOHEADER 20 #define EFILENAME 21 #define EDATE 22 #define EVERSION 23 #define EFILETYPE 24 #define ECREATOR 25 #define ENUMSTATES 26 #define ENUMTRANSITIONS 27 #define ENUMLABELS 28 #define ENUMPARAMETERS 29 #define ECOMMENTS 30 #define EINDEX 40 #define ELABEL 50 #define ESTATE 51 #define EPARAMETERS 52 #define ENOTRAILER 60 #define ECRC 61 #define ENEWSTATE 70 #define EFILEMODE 71 #endif mcrl2-201210.1/3rd-party/svc/include/svc/svc.h000664 001751 001751 00000006063 12042421220 021723 0ustar00jenkinsjenkins000000 000000 /* SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. $Id: svc.h,v 1.3 2008/09/30 08:22:51 bertl Exp $ */ /* Interface for the SVC level 2 interface */ #ifndef _SVC_H #define _SVC_H #include "mcrl2/aterm/aterm1.h" #include "svc1.h" typedef SVCint SVCstateIndex; typedef SVCint SVClabelIndex; typedef SVCint SVCparameterIndex; typedef struct { ltsFile file; struct ltsHeader header; long transitionNumber; } SVCfile; /* Datatype 'SVClabel' */ SVClabelIndex SVCnewLabel(SVCfile*, aterm::ATerm, SVCbool*); SVClabelIndex SVCaterm2Label(SVCfile*, aterm::ATerm); aterm::ATerm SVClabel2ATerm(SVCfile*, SVClabelIndex); /* Datatype 'SVCstate' */ SVCstateIndex SVCnewState(SVCfile*, aterm::ATerm, SVCbool*); SVCstateIndex SVCaterm2State(SVCfile*, aterm::ATerm); aterm::ATerm SVCstate2ATerm(SVCfile*, SVCstateIndex); /* Datatype 'SVCparameter' */ SVCparameterIndex SVCnewParameter(SVCfile*, aterm::ATerm, SVCbool*); SVCparameterIndex SVCaterm2Parameter(SVCfile*, aterm::ATerm); aterm::ATerm SVCparameter2ATerm(SVCfile*, SVCparameterIndex); /* Datatype 'SVCTransition' */ int SVCputTransition(SVCfile*, SVCstateIndex, SVClabelIndex, SVCstateIndex, SVCparameterIndex); int SVCgetNextTransition(SVCfile*, SVCstateIndex*, SVClabelIndex*, SVCstateIndex*, SVCparameterIndex*); /* File interface */ int SVCopen(SVCfile*, char*, SVCfileMode, SVCbool*); int SVCclose(SVCfile*); /* Functions to put and get header information */ char* SVCgetFormatVersion(SVCfile*); SVCbool SVCgetIndexFlag(SVCfile*); SVCstateIndex SVCgetInitialState(SVCfile*); int SVCsetInitialState(SVCfile*, SVCstateIndex); char* SVCgetComments(SVCfile*); int SVCsetComments(SVCfile*, char*); char* SVCgetCreator(SVCfile*); int SVCsetCreator(SVCfile*, char*); char* SVCgetType(SVCfile*); int SVCsetType(SVCfile*, char*); char* SVCgetVersion(SVCfile*); int SVCsetVersion(SVCfile*, char*); char* SVCgetDate(SVCfile*); char* SVCgetFilename(SVCfile*); SVCint SVCnumStates(SVCfile*); SVCint SVCnumLabels(SVCfile*); SVCint SVCnumParameters(SVCfile*); SVCint SVCnumTransitions(SVCfile*); std::string SVCerror(int); #endif mcrl2-201210.1/3rd-party/svc/include/svc/blocklist.h000664 001751 001751 00000003727 12042421220 023122 0ustar00jenkinsjenkins000000 000000 /* SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. $Id: blocklist.h,v 1.2 2008/09/30 08:22:51 bertl Exp $ */ #ifndef __BLOCKLIST_H #define __BLOCKLIST_H typedef unsigned short Bool; typedef struct HFnode* HFcursor; typedef struct { struct HFnode* first, *last; unsigned long frequency; } tBlock; typedef tBlock* BLcursor; typedef tBlock* BList; void BLinit(BList*); #define BLfirst(list) (list->first) #define BLnext(list) (list->last->next?list->last->next->block:NULL) #define BLprevious(list) (list->first->previous?list->first->previous->block:NULL) #define BLfrequency(cursor) (cursor->frequency) void BLinsert(BList*, struct HFnode*); void BLdeleteNode(BList*, struct HFnode*); void BLdelete(BList*, BLcursor); void BLfree(BList*); void Binit(tBlock*); #define Bfirst(list) (list->first) #define Blast(list) (list->last) #define Bnext(list) (list->next) #define Bprevious(list) (list->previous) void BLswap(BList*, struct HFnode*, struct HFnode*); void Binsert(tBlock*, struct HFnode*); void Bdelete(tBlock*, HFcursor); unsigned long Bfrequency(tBlock*); void Bfree(tBlock*); #endif mcrl2-201210.1/3rd-party/svc/include/svc/code.h000664 001751 001751 00000003451 12042421220 022040 0ustar00jenkinsjenkins000000 000000 /* SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. $Id: code.h,v 1.3 2008/09/30 08:22:51 bertl Exp $ */ #ifndef __CODE_H #define __CODE_H #ifdef __cplusplus extern "C" { #endif #define NO_INT INT_MAX #define NO_TERM NULL typedef unsigned char Bit; typedef unsigned char Byte; typedef struct { Byte buffer; unsigned short numBits; FILE* fp; long last; } BitStream; BitStream* BSinit(FILE*); void BSfree(BitStream*); void BSwriteBit(BitStream*, Bit); void BSwriteByte(BitStream*, Byte); void BSwriteChar(BitStream*, char); void BSwriteString(BitStream*, const char*); void BSwriteInt(BitStream*, long); int BSreadBit(BitStream*, Bit*); int BSreadChar(BitStream*, char*); int BSreadByte(BitStream*, Byte*); int BSreadString(BitStream*, char*); int BSreadInt(BitStream*, long*); void BSflush(BitStream*); int BSseek(BitStream*, long, int); long BStell(BitStream*); #ifdef __cplusplus } #endif #endif mcrl2-201210.1/3rd-party/svc/include/svc/ptable.h000664 001751 001751 00000002304 12042421220 022371 0ustar00jenkinsjenkins000000 000000 /* SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. $Id: ptable.h,v 1.2 2008/09/30 08:22:51 bertl Exp $ */ #include #define PT_INITIALSIZE 1024 typedef struct { long size; void** nodes; } PTable; void PTinit(PTable*); void PTput(PTable*, long index, void* ptr); void* PTget(PTable*, long index); void PTfree(PTable*); mcrl2-201210.1/3rd-party/svc/test/test_lib.cpp000664 001751 001751 00000000221 12042421220 022017 0ustar00jenkinsjenkins000000 000000 // empty test, just for testing if the libraries build correctly #include int test_main(int, char*[]) { return 0; } mcrl2-201210.1/3rd-party/svc/COPYING000664 001751 001751 00000001533 12042421220 017571 0ustar00jenkinsjenkins000000 000000 SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 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 Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. mcrl2-201210.1/3rd-party/svc/CMakeLists.txt000664 001751 001751 00000001676 12042421220 021306 0ustar00jenkinsjenkins000000 000000 # Authors: Frank Stappers and Aad Mathijssen # Copyright: see the accompanying file COPYING or copy at # https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING # # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) # ########## Project setup ########## project(svc) cmake_minimum_required(VERSION 2.6) # ######### General setup ########## # actual target: add_library(${PROJECT_NAME} source/huffman.cpp source/lz.cpp source/compress.cpp source/blocklist.cpp source/code.cpp source/ptable.cpp source/svc1.cpp source/svc2.cpp source/hashtable.cpp ) include_directories(${CMAKE_SOURCE_DIR}/3rd-party/svc/include) include_directories(${CMAKE_SOURCE_DIR}/libraries/aterm/include) target_link_libraries(${PROJECT_NAME} mcrl2_aterm ) # add install target: install(TARGETS ${PROJECT_NAME} DESTINATION ${MCRL2_LIB_DIR} COMPONENT Libraries) mcrl2-201210.1/3rd-party/svc/AUTHORS000664 001751 001751 00000002033 12042421220 017602 0ustar00jenkinsjenkins000000 000000 SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 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 Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. $Id: AUTHORS,v 1.1.1.1 2004/09/07 15:06:33 uid523 Exp $ Izak van Langevelde CWI Amsterdam The Netherlands email: izak@cwi.nl tel : +31 20 5924165 mcrl2-201210.1/3rd-party/svc/source/huffman.cpp000664 001751 001751 00000027304 12042421220 022172 0ustar00jenkinsjenkins000000 000000 /* SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include #include using namespace aterm; static ATerm ESCAPE_SEQUENCE; static ATerm NO_ATERM; static struct HFnode* HFadd(HFtree*, ATerm); static void HFwriteCode(BitStream*, struct HFnode*); static void HFfreeLoop(struct HFnode*); void HFdump(struct HFnode*, int); void HFstats(struct HFnode*, int, long*); void HFdumpCode(FILE*, struct HFnode*); /* Initialise 'tree' by adding one separator code */ int HFinit(HFtree* tree, HTable* terms) { /* Protect and assign constants */ ESCAPE_SEQUENCE=NULL; NO_ATERM=NULL; ATprotect(&ESCAPE_SEQUENCE); ATprotect(&NO_ATERM); ESCAPE_SEQUENCE=(ATerm)ATmakeAppl1(ATmakeAFun("ESC",1,true),(ATerm)ATmakeAppl0(ATmakeAFun("NEW",0,false))); NO_ATERM =(ATerm)ATmakeAppl1(ATmakeAFun("ESC",1,true),(ATerm)ATmakeAppl0(ATmakeAFun("NIL",0,false))); /* Init LZ buffer */ LZinit(&tree->buffer); /* Assign terms table */ tree->terms=terms; /* Create the root node */ tree->codes=(struct HFnode*)malloc(sizeof(struct HFnode)); tree->codes->high=NULL; tree->codes->parent=NULL; tree->codes->frequency=0L; tree->codes->term=NULL; ATprotect(&tree->codes->term); /* Create the leaf for the escape code */ tree->codes->low=(struct HFnode*)malloc(sizeof(struct HFnode)); tree->codes->low->high=NULL; tree->codes->low->low=NULL; tree->codes->low->parent=tree->codes; tree->codes->low->frequency=0L; tree->codes->low->term=ESCAPE_SEQUENCE; ATprotect(&tree->codes->low->term); /* Store the escape sequence term */ tree->top=tree->codes->low; /* Initialise the block list */ BLinit(&tree->blockList); BLinsert(&tree->blockList, tree->codes->low); BLinsert(&tree->blockList, tree->codes); return 1; } /* Free resources occupied by 'tree' */ void HFfree(HFtree* tree) { BLfree(&tree->blockList); HFfreeLoop(tree->codes); } void HFfreeLoop(struct HFnode* node) { if (node!=NULL) { HFfreeLoop(node->low); HFfreeLoop(node->high); ATunprotect(&node->term); free(node); } } void HFstats(struct HFnode* tree, int level, long* sum) { if (tree!=NULL) { if (tree->low==NULL && tree->high==NULL) { *sum+=tree->frequency*level; } else { HFstats(tree->low, level+1, sum); HFstats(tree->high, level+1, sum); } if (tree->parent==NULL) { fprintf(stderr, "Average code length is %ld bits\n", *sum/tree->frequency); } } } /* Write 'tree' to stderr */ void HFdump(struct HFnode* tree, int d) { int i; if (tree!=NULL) { if (tree->low==NULL && tree->high==NULL) { if (tree->term==NULL) { ATfprintf(stderr," (%d) Term NULL\n", tree->frequency); } else { ATfprintf(stderr," (%d) Term %t\n", tree->frequency, tree->term); } } else { fprintf(stderr," (%ld)\n", tree->frequency); for (i=0; ilow,d+1); for (i=0; ihigh,d+1); } } } /* Return the first node of 'current' in 'tree' in the left-to-right and bottom to top ordering */ static struct HFnode* HFsuccessor(HFtree*, struct HFnode* current) { tBlock* currentBlock; HFcursor last, prelast; currentBlock=current->block; last=Blast(currentBlock); prelast=Bprevious(last); if (last==current) { return NULL; } else { if (current==prelast) { if (current->parent==last || last->parent==current) { return NULL; } else { return last; } } else { if (current->parent==prelast || (prelast &&prelast->parent==current)) { if (current->parent==last || last->parent==current) { return NULL; } else { return last; } } else { return prelast; } } } } /* Swap in 'tree' the nodes 'node1' and 'node2' */ static void HFswap(struct HFnode** root, struct HFnode* node1, struct HFnode* node2) { struct HFnode** parent1Ptr, **parent2Ptr, *tmp; if (*root==node1) { parent1Ptr=root; } else { if (node1==node1->parent->low) { parent1Ptr=&node1->parent->low; } else { parent1Ptr=&node1->parent->high; } } if (*root==node2) { parent2Ptr=root; } else { if (node2==node2->parent->low) { parent2Ptr=&node2->parent->low; } else { parent2Ptr=&node2->parent->high; } } *parent1Ptr=node2; *parent2Ptr=node1; tmp=node2->parent; node2->parent=node1->parent; node1->parent=tmp; } /* Update 'tree' starting from 'current' */ static void HFupdate(HFtree* tree, struct HFnode* current) { struct HFnode* successor=NULL; for (; current!=NULL; current= current->parent) { successor=HFsuccessor(tree, current); if (successor==NULL) { BLswap(&tree->blockList, current, NULL); } else { BLswap(&tree->blockList, current, successor); HFswap(&tree->codes, current, successor); } } /* HFdump(tree->codes, 0); fprintf(stderr,"\n----------------------\n"); */ } int HFdecodeATerm(BitStream* fp, HFtree* tree, ATerm* term) { Bit bit; struct HFnode* current; current=tree->codes; while (current!=NULL) { if (current->high==NULL && current->low==NULL) { *term=current->term; if (*term==ESCAPE_SEQUENCE) { /* OEPS HFupdate(tree,current); */ if (LZreadATerm(fp, &tree->buffer, term)) { current=HFadd(tree,*term); HFupdate(tree,current); } else { fprintf(stderr, "Cannot read string\n"); return 0; } } else { HFupdate(tree,current); } if (*term==NO_ATERM) { *term=NULL; return 0; } else { return 1; } } else { if (BSreadBit(fp, &bit)==1) { if (bit==0) { current = current->low; } else { current = current->high; } } else { return 0; } } } return 1; } int HFdecodeIndex(BitStream* fp, HFtree* tree, long* index) { Bit bit; struct HFnode* current; ATerm term; current=tree->codes; while (current!=NULL) { if (current->high==NULL && current->low==NULL) { term=current->term; if (term==ESCAPE_SEQUENCE) { /* OEPS HFupdate(tree,current); */ if (LZreadInt(fp,&tree->buffer,index)) { term=(ATerm)ATmakeInt(*index); current=HFadd(tree,term); HFupdate(tree,current); return *index!=NO_INT; } else { return 0; } } else { HFupdate(tree,current); *index=ATgetInt((ATermInt)term); return *index!=NO_INT; } } else { if (BSreadBit(fp, &bit)==1) { if (bit==0) { current = current->low; } else { current = current->high; } } else { return 0; } } } return 1; } /* Insert 'term' into tree */ int HFencodeATerm(BitStream* bs, HFtree* tree, ATerm term) { struct HFnode* tmp; long index; if (term==NULL) { term=NO_ATERM; } if (HTmember(tree->terms,term,&index)&&HTgetPtr(tree->terms,index)) { tmp=(struct HFnode*)HTgetPtr(tree->terms,index); HFwriteCode(bs, tmp); HFupdate(tree,tmp); return 1; } else { tmp=tree->top; HFwriteCode(bs,tmp); /* OEPS HFupdate(tree,tmp); */ LZwriteATerm(bs, &tree->buffer, term); tmp=HFadd(tree,term); HFupdate(tree,tmp); return 0; } } int HFencodeIndex(BitStream* bs, HFtree* tree, long index) { struct HFnode* tmp; ATerm term; long n; term=(ATerm)ATmakeInt(index); if (HTmember(tree->terms,term,&n)&&HTgetPtr(tree->terms,n)) { tmp=(struct HFnode*)HTgetPtr(tree->terms,n); HFwriteCode(bs, tmp); HFupdate(tree,tmp); return 1; } else { tmp=tree->top; HFwriteCode(bs,tmp); /* OEPS HFupdate(tree,tmp); */ LZwriteInt(bs, &tree->buffer, index); tmp=HFadd(tree,term); HFupdate(tree,tmp); return 0; } } void HFdumpCode(FILE* fp, struct HFnode* node) { if (node->parent!=NULL) { HFdumpCode(fp,node->parent); if (node==node->parent->high) { fprintf(fp, "1"); } else { fprintf(fp, "0"); } } } void HFwriteCode(BitStream* fp, struct HFnode* node) { if (node->parent!=NULL) { HFwriteCode(fp,node->parent); if (node==node->parent->high) { BSwriteBit(fp,1); } else { BSwriteBit(fp,0); } } } /* Add 'term' to 'tree' */ static struct HFnode* HFadd(HFtree* tree, ATerm term) { struct HFnode* newNode, *tmp; long index; /* Find the node with the escape sequence */ tmp=tree->top; /* This is the only child of its parent? */ if (tmp->parent->high==NULL) { /* Create a new sibling */ newNode=(struct HFnode*)malloc(sizeof(struct HFnode)); newNode->high=NULL; newNode->low=NULL; newNode->parent=tmp->parent; newNode->frequency=0L; newNode->term=term; ATprotect(&newNode->term); tmp->parent->high=newNode; BLinsert(&tree->blockList, newNode); if (HTmember(tree->terms, term, &index)) { HTsetPtr(tree->terms,index, newNode); } else { HTinsert(tree->terms, term, newNode); } return newNode; } else { /* Create new interior node */ newNode=(struct HFnode*)malloc(sizeof(struct HFnode)); newNode->parent=tmp->parent; newNode->frequency=tmp->frequency; newNode->term=NULL; ATprotect(&newNode->term); if (tmp->parent->low==tmp) { tmp->parent->low=newNode; } else { tmp->parent->high=newNode; } /* Old leaf becomes low child of new node */ newNode->low=tmp; tmp->parent=newNode; /* Create new leaf that is high child of new interior node */ newNode->high=(struct HFnode*)malloc(sizeof(struct HFnode)); newNode->high->high=NULL; newNode->high->low=NULL; newNode->high->parent=newNode; newNode->high->frequency=0L; newNode->high->term=term; ATprotect(&newNode->high->term); BLinsert(&tree->blockList, newNode); BLinsert(&tree->blockList, newNode->high); /* HTinsert(tree->terms, term, newNode->high); */ if (HTmember(tree->terms, term, &index)) { HTsetPtr(tree->terms,index, newNode->high); } else { HTinsert(tree->terms, term, newNode->high); } return newNode->high; } } mcrl2-201210.1/3rd-party/svc/source/compress.cpp000664 001751 001751 00000011573 12042421220 022402 0ustar00jenkinsjenkins000000 000000 /* SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include using namespace aterm; static char buffer[102400]; static void calcDelta(CompressedStream*, long*); static void uncalcDelta(CompressedStream*, long*); CompressedStream* CSinit(HTable* table, BitStream* bs, int indexed) { CompressedStream* ret; ret=(CompressedStream*)malloc(sizeof(CompressedStream)); if (indexed) { ret->indices=table; HTinit(&ret->deltas); HFinit(&ret->tree, &ret->deltas); } else { HTinit(&ret->deltas); HFinit(&ret->tree, table); } ret->bs=bs; ret->last=0; ret->preLast=0; return ret; } void CSfree(CompressedStream* cs) { HFfree(&cs->tree); HTfree(&cs->deltas); free(cs); } int CSreadIndex(CompressedStream* cs, ATerm* term) { long index; if (HFdecodeIndex(cs->bs, &cs->tree, &index)) { uncalcDelta(cs,&index); *term=(ATerm)ATmakeInt(index); HTinsert(cs->indices,*term,NULL); /* IZAK */ return 1; } else { return 0; } } int CSreadATerm(CompressedStream* cs, ATerm* term) { if (HFdecodeATerm(cs->bs, &cs->tree, term)) { if (*term==NULL) { return 0; } else { return 1; } } else { return 0; } } int CSureadATerm(CompressedStream* cs, ATerm* term) { if (BSreadString(cs->bs,buffer)) { *term=ATreadFromString(buffer); return 1; } else { return 0; } } int CSreadString(CompressedStream* cs, char** str) { ATerm term; /* if(HFdecodeATerm(cs->bs, &cs->tree, &term) && ATmatch(term, "", str)){ */ if (HFdecodeATerm(cs->bs, &cs->tree, &term) && ATgetType(term)==AT_APPL && !ATisQuoted(ATgetAFun((ATermAppl)term))) { *str =ATgetName(ATgetAFun((ATermAppl)term)); return 1; } else { return 0; } } int CSureadString(CompressedStream* cs, char** str) { if (BSreadString(cs->bs, buffer)) { /* ATfprintf(stderr, "Uread %s\n", buffer); */ *str=buffer; return 1; } else { return 0; } } int CSreadInt(CompressedStream* cs, long* n) { ATerm term; /* if(HFdecodeATerm(cs->bs, &cs->tree, &term) && ATmatch(term, "", &n)) */ if (HFdecodeATerm(cs->bs, &cs->tree, &term) && ATgetType(term)==AT_INT) { *n =ATgetInt((ATermInt)term); return 1; } else { return 0; } } int CSureadInt(CompressedStream* cs, long* n) { if (BSreadInt(cs->bs,n)) { /* fprintf(stderr, "Read int %ld\n", *n); */ return 1; } else { return 0; } } int CSwriteIndex(CompressedStream* cs, ATerm term) { long index; if (term==NULL) { return HFencodeIndex(cs->bs, &cs->tree, NO_INT); } else { if (!HTmember(cs->indices,term,&index)) { index=HTinsert(cs->indices,term,NULL); } calcDelta(cs, &index); return HFencodeIndex(cs->bs, &cs->tree, index); } } int CSwriteATerm(CompressedStream* cs, ATerm term) { return HFencodeATerm(cs->bs, &cs->tree, term); } int CSuwriteATerm(CompressedStream* cs, ATerm term) { BSwriteString(cs->bs,ATwriteToString(term).c_str()); return 1; } int CSwriteString(CompressedStream* cs, const char* str) { return HFencodeATerm(cs->bs, &cs->tree, (ATerm)ATmakeAppl(ATmakeAFun(str,0,false))); } int CSuwriteString(CompressedStream* cs, const char* str) { BSwriteString(cs->bs,str); return 1; } int CSwriteInt(CompressedStream* cs, long n) { /* ATfprintf(stderr,"Write int %d\n", n); */ return HFencodeATerm(cs->bs, &cs->tree, (ATerm)ATmakeInt(n)); } int CSuwriteInt(CompressedStream* cs, long n) { BSwriteInt(cs->bs,n); return 1; } void CSflush(CompressedStream* cs) { BSflush(cs->bs); } int CSseek(CompressedStream* cs, long offset, int whence) { return BSseek(cs->bs, offset, whence); } long CStell(CompressedStream* cs) { return BStell(cs->bs); } static void calcDelta(CompressedStream* bs, long* n) { long tmp; tmp=*n; *n=*n-bs->preLast; bs->preLast=bs->last; bs->last=tmp; } static void uncalcDelta(CompressedStream* bs, long* n) { *n=*n+bs->preLast; bs->preLast=bs->last; bs->last=*n; } mcrl2-201210.1/3rd-party/svc/source/svc1.cpp000664 001751 001751 00000030414 12042421220 021416 0ustar00jenkinsjenkins000000 000000 /* SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. $Id: svc1.cpp 10475 2012-04-11 14:43:24Z jkeiren $ */ // C includes #include #include #include #if defined(_MSC_VER) # include #endif // svc includes #include #include #if !(defined __USE_SVID || defined __USE_BSD || defined __USE_XOPEN_EXTENDED || defined __APPLE__ || defined _MSC_VER) extern char* _strdup(const char* s); #endif using namespace aterm; int svcErrno; /* Initialise `file' with file `filename' */ int svcInit(ltsFile* file, char* filename, SVCfileMode fileMode, SVCbool* indexed) { FILE* fp; Bit indexFlag; file->fileMode=fileMode; if (fileMode==SVCread) { fp=fopen(filename,"rb"); if (fp==NULL) { svcErrno=EACCESS; return -1; #ifdef _MSC_VER _setmode(_fileno(fp),_O_BINARY); #endif } else { HTinit(&file->stateTable); HTinit(&file->labelTable); HTinit(&file->parameterTable); /* Init bit stream and read index bit */ file->bs=BSinit(fp); BSreadBit(file->bs,&indexFlag); *indexed=static_cast(indexFlag); file->indexFlag=static_cast(indexFlag); /* Init compressed streams */ file->csStates=CSinit(&file->stateTable, file->bs, *indexed); file->csLabels=CSinit(&file->labelTable, file->bs, 0); file->csParameters=CSinit(&file->parameterTable, file->bs, 0); /* Read file index */ if (CSureadInt(file->csStates, &file->headerPosition) && CSureadInt(file->csStates, &file->bodyPosition) && CSureadInt(file->csStates, &file->trailerPosition) && CSureadInt(file->csStates, &file->versionPosition)) { file->firstTransition=static_cast(1); /* The first 30 bytes are reserved for de file index, bodyPosition must be always 30 */ if ((file->bodyPosition!=30) && (file->bodyPosition!=0)) { svcErrno=EINDEX; return -1; } return 0; } else { svcErrno=EINDEX; return -1; } } } else { fp=fopen(filename,"wb"); if (fp==NULL) { svcErrno=EACCESS; return -1; } else { HTinit(&file->stateTable); HTinit(&file->labelTable); HTinit(&file->parameterTable); /* Init compressed streams */ file->bs=BSinit(fp); file->csStates=CSinit(&file->stateTable, file->bs, *indexed); file->csLabels=CSinit(&file->labelTable, file->bs, *indexed); file->csParameters=CSinit(&file->parameterTable, file->bs, *indexed); /* Reserve space for file index */ ATfprintf(fp, " \n"); file->headerPosition=0L; file->bodyPosition=0L; file->trailerPosition=0L; file->versionPosition=0L; file->firstTransition=static_cast(1); return 0; } } } /* Read the format version from `fp' into `version' */ int svcReadVersion(ltsFile* file, char** version) { char* str; CSflush(file->csStates); CSseek(file->csStates, file->versionPosition, SEEK_SET); if (CSureadString(file->csStates, &str)) { *version=_strdup(str); return 0; } svcErrno=EVERSION; return -1; } /* svcReadVersion */ /* Read the header from `bs' into `header' */ int svcReadHeader(ltsFile* file, struct ltsHeader* header) { char* str; CSflush(file->csStates); CSseek(file->csStates, file->headerPosition, SEEK_SET); /* if (!CSureadATerm(file->csStates, &tmp) || tmp!= SVC_HEADERLABEL){ svcErrno=ENOHEADER; return -1; } */ if (!CSureadString(file->csStates,&str)) { svcErrno=EFILENAME; return -1; } header->filename=_strdup(str); if (!CSureadString(file->csStates,&str)) { svcErrno=EDATE; return -1; } header->date=_strdup(str); if (!CSureadString(file->csStates,&str)) { svcErrno=EVERSION; return -1; } header->version=_strdup(str); if (!CSureadString(file->csStates,&str)) { svcErrno=EFILETYPE; return -1; } header->type=_strdup(str); if (!CSureadString(file->csStates, &str)) { svcErrno=ECREATOR; return -1; } header->creator=_strdup(str); if (!CSureadInt(file->csStates, &header->numStates)) { svcErrno=ENUMSTATES; return -1; } if (!CSureadInt(file->csStates, &header->numTransitions)) { svcErrno=ENUMTRANSITIONS; return -1; } if (!CSureadInt(file->csStates, &header->numLabels)) { svcErrno=ENUMLABELS; return -1; } if (!CSureadInt(file->csStates, &header->numParameters)) { svcErrno=ENUMPARAMETERS; return -1; } if (!CSureadString(file->csStates,&str)) { svcErrno=ECOMMENTS; return -1; } header->initialState=_strdup(str); if (!CSureadString(file->csStates, &str)) { svcErrno=ECOMMENTS; return -1; } header->comments=_strdup(str); return 0; } /* svcReadHeader */ /* Read the next transition from `file' into `transition' */ int svcReadNextTransition(ltsFile* file, struct ltsTransition* transition) { if (file->bodyPosition==0) { svcErrno=EINDEX; return -1; } if (file->firstTransition) { CSflush(file->csStates); CSseek(file->csStates, file->bodyPosition, SEEK_SET); file->firstTransition=static_cast(0); } if (file->indexFlag) { if (!CSreadIndex(file->csStates, &transition->fromState)) { return -1; } if (!CSreadATerm(file->csLabels, &transition->label)) { svcErrno=ELABEL; return -1; } if (!CSreadIndex(file->csStates, &transition->toState)) { svcErrno=ESTATE; return -1; } if (!CSreadATerm(file->csParameters, &transition->parameters)) { svcErrno=EPARAMETERS; return -1; } } else { if (!CSreadATerm(file->csStates, &transition->fromState)) { return -1; } if (!CSreadATerm(file->csLabels, &transition->label)) { svcErrno=ELABEL; return -1; } if (!CSreadATerm(file->csStates, &transition->toState)) { svcErrno=ESTATE; return -1; } if (!CSreadATerm(file->csParameters, &transition->parameters)) { svcErrno=EPARAMETERS; return -1; } } return 0; } /* svcReadNextTransition */ /* Read the trailer from `file' and check the crc */ int svcReadTrailer(ltsFile* file) { long crc32; CSseek(file->csStates, file->trailerPosition, SEEK_SET); /* if (!CSreadATerm(file->csStates, &tmp) || tmp!=SVC_TRAILERLABEL){ svcErrno=ENOTRAILER; return -1; } */ if (!CSreadInt(file->csStates, &crc32)) { svcErrno=ECRC; return -1; } return 0; } /* svcReadTrailer */ /* Write the version of the file format into `bs' */ int svcWriteVersion(ltsFile* file) { CSflush(file->csStates); file->versionPosition=CStell(file->csStates); CSuwriteString(file->csStates, SVC_VERSION); return 0; } /* svcWriteVersion */ /* Write the file header from `header' into `fp' */ int svcWriteHeader(ltsFile* file, struct ltsHeader* header) { if (file->indexFlag) { CSwriteIndex(file->csStates, NULL); } else { CSwriteATerm(file->csStates, NULL); } CSflush(file->csStates); file->headerPosition=CStell(file->csStates); /* CSuwriteATerm(file->csStates, SVC_HEADERLABEL); */ CSuwriteString(file->csStates, header->filename); CSuwriteString(file->csStates, header->date); CSuwriteString(file->csStates, header->version); CSuwriteString(file->csStates, header->type); CSuwriteString(file->csStates, header->creator); CSuwriteInt(file->csStates, header->numStates); CSuwriteInt(file->csStates, header->numTransitions); CSuwriteInt(file->csStates, header->numLabels); CSuwriteInt(file->csStates, header->numParameters); CSuwriteString(file->csStates, header->initialState); CSuwriteString(file->csStates, header->comments); return 0; } /* svcWriteHeader */ /* Write the transition from `transition' into `fp' */ int svcWriteTransition(ltsFile* file, struct ltsTransition* transition) { if (file->bodyPosition==0L) { CSflush(file->csStates); file->bodyPosition=CStell(file->csStates); } /* CSwriteATerm(file->csStates, transition->fromState); CSwriteATerm(file->csLabels, transition->label); CSwriteATerm(file->csStates, transition->toState); CSwriteATerm(file->csParameters, transition->parameters); */ if (file->indexFlag) { CSwriteIndex(file->csStates, transition->fromState); CSwriteATerm(file->csLabels, transition->label); CSwriteIndex(file->csStates, transition->toState); CSwriteATerm(file->csParameters, transition->parameters); } else { CSwriteATerm(file->csStates, transition->fromState); CSwriteATerm(file->csLabels, transition->label); CSwriteATerm(file->csStates, transition->toState); CSwriteATerm(file->csParameters, transition->parameters); } return 0; } /* svcWriteTransition */ /* Write the trailer with computed CRC into `fp' */ int svcWriteTrailer(ltsFile* file) { CSflush(file->csStates); file->trailerPosition=CStell(file->csStates); /* ATfprintf(file->fp, "%t %d\n", SVC_TRAILERLABEL, 666); */ /* CSwriteATerm(file->csStates, SVC_TRAILERLABEL); */ CSwriteInt(file->csStates, 666); return 0; } /* svcWriteTrailer */ int svcFree(ltsFile* file) { if (file->fileMode==SVCwrite) { /* Write index */ CSflush(file->csStates); CSseek(file->csStates, 0L, SEEK_SET); BSwriteBit(file->bs,file->indexFlag); CSuwriteInt(file->csStates, file->headerPosition); CSuwriteInt(file->csStates, file->bodyPosition); CSuwriteInt(file->csStates, file->trailerPosition); CSuwriteInt(file->csStates, file->versionPosition); CSflush(file->csStates); } /* Clean up memory */ HTfree(&file->stateTable); HTfree(&file->labelTable); HTfree(&file->parameterTable); CSfree(file->csStates); CSfree(file->csLabels); CSfree(file->csParameters); BSfree(file->bs); free(file->formatVersion); return 0; } /* Return an error message string for the svc error number in `errnum' */ std::string svcError(int errnum) { switch (errnum) { case EINDEX: return "index section not found"; case ENOHEADER: return "header section not found"; case EFILENAME: return "filename in header not found"; case EDATE : return "date in header not found"; case EVERSION : return "version in header not found"; case EFILETYPE: return "filetypein header not found"; case ECREATOR : return "creator in header not found"; case ENUMSTATES: return "number of states in header not found"; case ENUMTRANSITIONS: return "number of transitions in header not found"; case ENUMLABELS: return "number of labels in header not found"; case ENUMPARAMETERS: return "number of parameters in header not found"; case ECOMMENTS: return "comments in header not found"; case EACCESS: return strerror(errno); case ENOINFO: return "information section not found"; case EFORMATVERSION: return "version in information not found"; case ELABEL: return "label in transition not found"; case ESTATE: return "state in transition not found"; case EPARAMETERS: return "parameter in transition not found"; case ENOTRAILER: return "trailer section not found"; case ECRC: return "crc in trailer not found"; default: return "Errno undefined"; } } /* svcError */ mcrl2-201210.1/3rd-party/svc/source/lz.cpp000664 001751 001751 00000015743 12042421220 021177 0ustar00jenkinsjenkins000000 000000 /* SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. $Id: lz.cpp 10945 2012-08-22 08:03:45Z scranen $ */ /* Bert Lisser: scratch buffer changed from fixed data array into reallocable array on the heap. Added function "int add2scratch(int last, char *c)" */ #include #include #include #include using namespace aterm; #if !(defined __USE_SVID || defined __USE_BSD || defined __USE_XOPEN_EXTENDED || defined __APPLE__ || defined _MSC_VER) extern char* _strdup(const char* s); #endif static int compress(BitStream* bs, LZbuffer* buffer, char* string_); static int decompress(BitStream* bs, LZbuffer* buffer, char** str); static void LZmakeToken(char c, unsigned int offset, unsigned int length, LZtoken token); static void LZsplitToken(char* c, unsigned int* offset, unsigned int* length, LZtoken token); static void LZwriteToken(BitStream* bs, LZtoken token); static int LZreadToken(BitStream* bs, LZtoken token); #define STEPSCRATCHSIZE 102400; static char* scratch = NULL; static int scratchSize = 0; static int count=0; void LZinit(LZbuffer* buffer) { int i; buffer->last=-1; buffer->read=1; buffer->written=1; for (i=0; isearch[i]='\0'; } } static void LZmakeToken(char c, unsigned int offset, unsigned int length, LZtoken token) { /* if (length<=1){ token[0]=c; token[1]='\0'; } else { token[0]=0x80|(unsigned char)length<<(SEARCH_BITS-8)|(unsigned char)(offset/256); token[1]=(offset%256); } */ if (length<=1) { token[0]=c; token[1]=0; token[2]=0; } else { token[0]=0x80|(unsigned char)(length/2); token[1]=(unsigned char)length<<7|(unsigned char)(offset/256); token[2]=(unsigned char)(offset%256); } } static void LZsplitToken(char* c, unsigned int* offset, unsigned int* length, LZtoken token) { /* if(token[0]&0x80){ *offset=(token[0]&0x03)*256+token[1]; *length=(token[0]&0x7c)>>(SEARCH_BITS-8); } else { *c=token[0]; *offset=0; *length=0; } */ if (token[0]&0x80) { *offset=(token[1]&0x7f)*256+token[2]; *length=(token[0]&0x7f)<<1|(token[1]&0x80)>>7; } else { *c=token[0]; *offset=0; *length=0; } } static void LZwriteToken(BitStream* bs, LZtoken token) { if (token[0]&0x80) { /* fprintf(stderr, "WRITING TOKEN %02X%02X%02X\n", token[0], token[1], token[2]); */ BSwriteByte(bs, token[0]); BSwriteByte(bs, token[1]); BSwriteByte(bs, token[2]); /* ADDED */ } else { BSwriteByte(bs, token[0]); } } static int LZreadToken(BitStream* bs, LZtoken token) { /* if(fscanf(fp, "%c", token)==1){ */ if (BSreadByte(bs, &token[0])==1) { if (token[0]&0x80) { BSreadByte(bs, &token[1]); BSreadByte(bs, &token[2]); /* ADDED */ /* fscanf(fp, "%c", &token[1]); */ } else { token[1]=0; } return 1; } else { return 0; } } int LZwriteString(BitStream* bs, LZbuffer* buffer, char* string_) { compress(bs,buffer,string_); return 1; } int LZreadString(BitStream* bs, LZbuffer* buffer, char** string_) { decompress(bs,buffer,string_); return 1; } int LZreadInt(BitStream* bs, LZbuffer*, long* n) { return BSreadInt(bs,n); } int LZwriteInt(BitStream* bs, LZbuffer*, long n) { BSwriteInt(bs,n); return 1; } int LZwriteATerm(BitStream* bs, LZbuffer* buffer, ATerm term) { char* buf; buf=_strdup(ATwriteToString(term).c_str()); compress(bs,buffer,buf); free(buf); return 1; } int LZreadATerm(BitStream* bs, LZbuffer* buffer, ATerm* term) { char* str; if (decompress(bs,buffer,&str)) { *term=ATreadFromString(str); /* *term=ATmake(str);*/ return 1; } else { return 0; } } static int compress(BitStream* bs, LZbuffer* buffer, char* string_) { int i=0,j=0,k=0; int offset=0,length=0; LZtoken token; char c; do { length=1; offset=0; c=string_[i]; for (j=0; jsearch[(buffer->last-j+k+SEARCHBUF_SIZE)%SEARCHBUF_SIZE]&&ksearch[(buffer->last+k+1+SEARCHBUF_SIZE)%SEARCHBUF_SIZE]=string_[i+k]; } if (string_[i+k]=='\0'&& buffer->search[(buffer->last-j+k+SEARCHBUF_SIZE)%SEARCHBUF_SIZE]=='\0' && klength) { offset=j; length=k; } if (c=='\0' || k==LOOKAHEADBUF_SIZE) { break; } } buffer->search[(buffer->last+length)%SEARCHBUF_SIZE]=string_[i+length-1]; LZmakeToken(c, offset, length, token); LZwriteToken(bs, token); buffer->last=(buffer->last+length)%SEARCHBUF_SIZE; i+=length; } while (string_[i-1]!='\0'); return 1; } static int add2scratch(int last, char ch) { if (last>=scratchSize) { if (scratchSize==0) { scratchSize=STEPSCRATCHSIZE; } else { scratchSize=2*scratchSize; } scratch = (char*)realloc(scratch, scratchSize); if (scratch==NULL) { fprintf(stderr,"Cannot realloc scratchbuffer in lz.c (svc library)\n"); exit(1); } } scratch[last++] = ch; return last; } static int decompress(BitStream* bs, LZbuffer* buffer, char** str) { unsigned int offset, length, i, last; LZtoken token; char c; /* *str=scratch; */ last=0; count++; while (LZreadToken(bs,token)) { LZsplitToken(&c, &offset, &length, token); if (length==0) { buffer->last=(buffer->last+1)%SEARCHBUF_SIZE; buffer->search[buffer->last]=c; last = add2scratch(last, c); /* scratch[last++]=c; */ } else { for (i=0; ilast=(buffer->last+1)%SEARCHBUF_SIZE; buffer->search[buffer->last]=buffer->search[(buffer->last-offset-1+SEARCHBUF_SIZE)%SEARCHBUF_SIZE]; last = add2scratch(last,buffer->search[buffer->last]); /* scratch[last++]=buffer->search[buffer->last]; */ } } *str=scratch; if (scratch[last-1]=='\0') { return 1; } } return 0; } mcrl2-201210.1/3rd-party/svc/source/blocklist.cpp000664 001751 001751 00000013345 12042421220 022534 0ustar00jenkinsjenkins000000 000000 /* SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include #include #include using namespace aterm; void BLdump(FILE*, BList*); void BLinit(BList* list) { *list=NULL; } void BLinsert(BList* blockList, struct HFnode* node) { node->frequency=0L; if (*blockList==NULL) { node->previous=NULL; node->next=NULL; *blockList=(tBlock*)malloc(sizeof(tBlock)); Binit(*blockList); } else { node->previous=NULL; node->next =(*blockList)->first; (*blockList)->first->previous=node; (*blockList)->first=node; } Binsert(*blockList,node); } /* void BLdelete(BList *blockList, BLcursor cursor) { tBlock *tmp; tmp=cursor; / * if(tmp->previous==NULL) { blockList->first=tmp->next; } else { tmp->previous->next=tmp->next; } if(tmp->next!=NULL) { tmp->next->previous=tmp->previous; } * / free(tmp); } */ void BLfree(BList* blockList) { tBlock* tmp; while (*blockList!=NULL) { tmp=(*blockList)->last->next?(*blockList)->last->next->block:NULL; free(*blockList); *blockList=tmp; } } void Binit(tBlock* list) { list->first=NULL; list->last=NULL; list->frequency=0L; } void BLswap(BList* blockList, struct HFnode* node1, struct HFnode* node2) { tBlock* newBlock; if (node2==NULL) { /* Remove node1 from its block */ if (node1->block->first==node1 && node1->block->last==node1) { if (*blockList==node1->block) { *blockList=NULL; } Bfree(node1->block); } else { if (node1->block->last==node1) { node1->block->last=node1->previous; } else { if (node1->block->first==node1) { node1->block->first=node1->next; } /* Shift node1 over this block */ if (node1->previous!=NULL) { node1->previous->next=node1->next; } if (node1->next!=NULL) { node1->next->previous=node1->previous; } node1->previous=node1->block->last; node1->next =node1->block->last->next; } } } else { if (node1->block->first==node1) { node1->block->first=node2; } if (node1->next!=node2) { if (node1->block->last==node2) { node1->block->last=node2->previous; } node2->previous->next=node2->next; if (node2->next!=NULL) { node2->next->previous=node2->previous; } node2->next=node1->next; } node2->previous=node1->previous; if (node2->previous!=NULL) { node2->previous->next=node2; } if (node2->next!=NULL) { node2->next->previous=node2; } node1->previous=node1->block->last; node1->next =node1->block->last->next; } node1->frequency++; if (node1->next!=NULL && node1->next->block->frequency==node1->frequency) { Binsert(node1->next->block, node1); } else { newBlock=(tBlock*)malloc(sizeof(tBlock)); Binit(newBlock); Binsert(newBlock,node1); } if (*blockList==NULL) { *blockList=node1->block; } if (node1->previous!=NULL) { node1->previous->next=node1; } if (node1->next!=NULL) { node1->next->previous=node1; } } void Binsert(tBlock* nodeList, struct HFnode* node) { if (nodeList->last==NULL) { nodeList->last=node; } nodeList->first=node; nodeList->frequency=node->frequency; node->block=nodeList; } void Bdelete(tBlock* nodeList, HFcursor cursor) { if (cursor->previous!=NULL) { cursor->previous->next=cursor->next; } if (cursor->next!=NULL) { cursor->next->previous=cursor->previous; } if (nodeList->last==cursor && nodeList->first==cursor) { nodeList->last=NULL; nodeList->first=NULL; } else { if (nodeList->last==cursor) { nodeList->last=cursor->previous; } if (nodeList->first==cursor) { nodeList->first=cursor->next; } } } unsigned long Bfrequency(tBlock* nodeList) { return nodeList->frequency; } void Bfree(tBlock* nodeList) { free(nodeList); } /* void BLdeleteNode(BList *blockList, struct HFnode *node){ Bdelete(node->block, node); if(node->block->first==NULL){ free(node->block); BLdelete(blockList, node->block); } } */ static void Bdump(FILE* fp, tBlock* block) { struct HFnode* tmp; fprintf(fp, "Block %ld:\n", block->frequency); for (tmp=block->first; tmp!=NULL; tmp=tmp->next) { ATfprintf(stderr, " %t %6d(%p<%p<%p)\n", tmp->term?tmp->term:(ATerm)ATmakeAppl0(ATmakeAFun("nil",0,false)), tmp->frequency, tmp->previous, tmp, tmp->next); if (tmp==block->last) { break; } } } void BLdump(FILE* fp, BList* blockList) { tBlock* tmp; fprintf(fp, "Blocklist:\n"); for (tmp=*blockList; tmp!=NULL; tmp=BLnext(tmp)) { Bdump(fp, tmp); } } mcrl2-201210.1/3rd-party/svc/source/hashtable.cpp000664 001751 001751 00000005577 12042421220 022511 0ustar00jenkinsjenkins000000 000000 /* SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* * This module implements a hash table for storing mCRL states, * represented as term-number pairs. All the states stored in a * table are protected by being inserted in a protected ATerm * list constructed with "ins" and "emt". The hashing function * assumes that each ATerm address is unique. The operations * provided are insertion and membership. */ /* Changes per 1/1/00 by Izak van Langevelde: - numbers used are unsigned long instead of long, 0 means absent - indices returned are in the range 1..N, but internally in the term table the entries are in the range 0..N-1 - hash table is parameter instead of global variable - errors are flagged by return value instead of error message Changes per 1/5/00 by Izak van Langevelde: - use the new ATerm lib with indexed sets*/ #include using namespace aterm; /* ======= Initialize the hash table ======= */ int HTinit(HTable* table) { table->terms=ATindexedSetCreate(PT_INITIALSIZE, 75); PTinit(&table->pointers); return 0; } void HTfree(HTable* table) { ATindexedSetDestroy(table->terms); PTfree(&table->pointers); } unsigned int HTinsert(HTable* table, ATerm a, void* ptr) { bool _new; unsigned int ret; ret= (unsigned int)ATindexedSetPut(table->terms, a, &_new); PTput(&table->pointers,ret,ptr); return ret; } int HTmember(HTable* table, ATerm a, long* pn) { int index; index=(int)ATindexedSetGetIndex(table->terms,a); if (index!=-1) { *pn=index; return 1; } else { return 0; } } /*----------------------------------------------------------*/ /* Get the term belonging to an index */ ATerm HTgetTerm(HTable* table, long n) { return ATindexedSetGetElem(table->terms,n); } /*----------------------------------------------------------*/ /* Get the stored pointer belonging to an index */ void* HTgetPtr(HTable* table, long n) { return PTget(&table->pointers,n); } void HTsetPtr(HTable* table, long n, void* ptr) { PTput(&table->pointers, n,ptr); } mcrl2-201210.1/3rd-party/svc/source/ptable.cpp000664 001751 001751 00000003074 12042421220 022013 0ustar00jenkinsjenkins000000 000000 /* SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include static void PTexpand(PTable*, long); void PTinit(PTable* table) { table->size=PT_INITIALSIZE; table->nodes=(void**)malloc(PT_INITIALSIZE*sizeof(void*)); } void PTput(PTable* table, long index, void* ptr) { if (table->sizenodes[index]=ptr; } void* PTget(PTable* table, long index) { return table->nodes[index]; } void PTfree(PTable* table) { free(table->nodes); } void PTexpand(PTable* table, long size) { while (table->sizesize=table->size<<2; } table->nodes=(void**)realloc(table->nodes,table->size*sizeof(void*)); } mcrl2-201210.1/3rd-party/svc/source/svc2.cpp000664 001751 001751 00000023476 12042421220 021431 0ustar00jenkinsjenkins000000 000000 /* SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. $Id: svc2.cpp 10475 2012-04-11 14:43:24Z jkeiren $ */ #include #include #include #include #if !(defined __USE_SVID || defined __USE_BSD || defined __USE_XOPEN_EXTENDED || defined __APPLE__ || defined _MSC_VER) extern char* _strdup(const char* s); #endif using namespace aterm; extern int svcErrno; int SVCerrno; /* SVCnewLabel assigns a new index to a label of a transition, given as an ATerm. The last variable indicates whether the addition is actually a new one (1=new). SVCnewLabel returns 0 if an error occurred, for instance because there is no room left to store the new term */ SVClabelIndex SVCnewLabel(SVCfile* file, ATerm term, SVCbool* _new) { SVClabelIndex index; if (HTmember(&file->file.labelTable, term, &index)) { *_new=SVCfalse; return index; } else { *_new=SVCtrue; if (file->file.fileMode==SVCwrite) { file->header.numLabels++; } return HTinsert(&file->file.labelTable, term, NULL); } } /* SVCaterm2Label gives the label index belonging to an ATerm. If no such label exists, the value -1 is returned */ SVClabelIndex SVCaterm2Label(SVCfile* file, ATerm term) { SVClabelIndex index; if (HTmember(&file->file.labelTable, term, &index)) { return index; } else { return -1L; } } /* SVClabel2ATerm provides the ATerm that belongs to a label index. In case of an error NULL is returned */ ATerm SVClabel2ATerm(SVCfile* file, SVClabelIndex index) { return HTgetTerm(&file->file.labelTable, index); } SVCstateIndex SVCnewState(SVCfile* file, ATerm term, SVCbool* _new) { SVCstateIndex index; if (HTmember(&file->file.stateTable, term, &index)) { *_new=SVCfalse; } else { *_new=SVCtrue; if (file->file.fileMode==SVCwrite) { file->header.numStates++; } index=HTinsert(&file->file.stateTable, term, NULL); } return index; } SVCstateIndex SVCaterm2State(SVCfile* file, ATerm term) { SVCstateIndex index; if (HTmember(&file->file.stateTable, term, &index)) { return index; } else { return -1L; } } ATerm SVCstate2ATerm(SVCfile* file, SVCstateIndex index) { return HTgetTerm(&file->file.stateTable, index); } SVCparameterIndex SVCnewParameter(SVCfile* file, ATerm term, SVCbool* _new) { SVCparameterIndex index; if (HTmember(&file->file.parameterTable, term, &index)) { *_new=SVCfalse; return index; } else { *_new=SVCtrue; if (file->file.fileMode==SVCwrite) { file->header.numParameters++; } return HTinsert(&file->file.parameterTable, term,NULL); } } SVCparameterIndex SVCaterm2Parameter(SVCfile* file, ATerm term) { SVCparameterIndex index; if (HTmember(&file->file.parameterTable, term, &index)) { return index; } else { return -1L; } } ATerm SVCparameter2ATerm(SVCfile* file, SVCparameterIndex index) { return HTgetTerm(&file->file.parameterTable, index); } int SVCputTransition(SVCfile* file, SVCstateIndex fromStateIndex, SVClabelIndex labelIndex, SVCstateIndex toStateIndex, SVCparameterIndex paramIndex) { struct ltsTransition transition; ATerm fromStateTerm, toStateTerm, labelTerm, paramTerm; int ret; fromStateTerm=HTgetTerm(&file->file.stateTable, fromStateIndex); toStateTerm=HTgetTerm(&file->file.stateTable, toStateIndex); labelTerm=HTgetTerm(&file->file.labelTable, labelIndex); paramTerm=HTgetTerm(&file->file.parameterTable, paramIndex); if (fromStateTerm != NULL && toStateTerm !=NULL && labelTerm != NULL && paramTerm != NULL) { transition.fromState=fromStateTerm; transition.toState=toStateTerm; transition.label=labelTerm; transition.parameters=paramTerm; ret=svcWriteTransition(&file->file, &transition); file->header.numTransitions++; return ret; } else { return 0; } } int SVCgetNextTransition(SVCfile* file, SVCstateIndex* fromStateIndex, SVClabelIndex* labelIndex, SVCstateIndex* toStateIndex, SVCparameterIndex* paramIndex) { struct ltsTransition transition; if (file->transitionNumber>=file->header.numTransitions) { return 0; } if (svcReadNextTransition(&file->file, &transition)==0) { file->transitionNumber++; HTmember(&file->file.stateTable,transition.fromState,fromStateIndex); HTmember(&file->file.stateTable,transition.toState,toStateIndex); HTmember(&file->file.parameterTable,transition.parameters,paramIndex); HTmember(&file->file.labelTable,transition.label,labelIndex); return 1; } else { return 0; } } int SVCopen(SVCfile* file, char* filename, SVCfileMode mode, SVCbool* indexed) { char* version; char buffy[256]; time_t now; SVCbool _new; file->transitionNumber = 0L; switch (mode) { case SVCwrite: if (svcInit(&file->file, filename, SVCwrite, indexed)>=0) { (void) time(&now); strftime(buffy,256,"%x", localtime(&now)); file->header.comments=_strdup(""); file->header.type=_strdup("generic"); file->header.version=_strdup("0.0"); file->header.filename=_strdup(filename); file->header.date=_strdup(buffy); file->header.creator=_strdup("svclib"); file->header.initialState=_strdup("0"); file->header.numStates=0L; file->header.numTransitions=0L; file->header.numLabels=0L; file->header.numParameters=0L; file->file.indexFlag=*indexed; file->file.formatVersion=_strdup(SVC_VERSION); return 0; } else { SVCerrno=svcErrno; return -1; } case SVCread: if (svcInit(&file->file, filename, SVCread, indexed)>=0) { if (svcReadVersion(&file->file, &version)==0 && svcReadHeader(&file->file, &file->header)==0) { file->file.formatVersion=version; if (SVCnewState(file, ATreadFromString(file->header.initialState), &_new)<0) { SVCerrno=ENEWSTATE; return -1; } return 0; } else { SVCerrno=svcErrno; return -1; } } else { SVCerrno=svcErrno; return -1; } default: SVCerrno=EFILEMODE; return -1; } } int SVCclose(SVCfile* file) { if (file->file.fileMode==SVCwrite) { /* Write file header and trailer */ svcWriteHeader(&file->file,&file->header); svcWriteVersion(&file->file); svcWriteTrailer(&file->file); } /* Clean up memory */ svcFree(&file->file); free(file->header.comments); free(file->header.type); free(file->header.version); free(file->header.filename); free(file->header.date); free(file->header.creator); free(file->header.initialState); /* Close file */ return 0; } char* SVCgetFormatVersion(SVCfile* file) { return file->file.formatVersion; } SVCbool SVCgetIndexFlag(SVCfile* file) { return file->file.indexFlag; } SVCstateIndex SVCgetInitialState(SVCfile* file) { return SVCaterm2State(file, ATreadFromString(file->header.initialState)); } int SVCsetInitialState(SVCfile* file, SVCstateIndex index) { char str[16]; free(file->header.initialState); if (file->file.indexFlag) { sprintf(str,"%ld",index); file->header.initialState=_strdup(str); } else { file->header.initialState=_strdup(ATwriteToString(SVCstate2ATerm(file,index)).c_str()); } return 0; } /* Functions to put and get header information */ char* SVCgetComments(SVCfile* file) { return file->header.comments; } int SVCsetComments(SVCfile* file, char* comments) { free(file->header.comments); file->header.comments=_strdup(comments); return 0; } char* SVCgetType(SVCfile* file) { return file->header.type; } int SVCsetType(SVCfile* file, char* type) { free(file->header.type); file->header.type=_strdup(type); return 0; } char* SVCgetVersion(SVCfile* file) { return file->header.version; } int SVCsetVersion(SVCfile* file, char* version) { free(file->header.version); file->header.version=_strdup(version); return 0; } char* SVCgetCreator(SVCfile* file) { return file->header.creator; } int SVCsetCreator(SVCfile* file, char* creator) { free(file->header.creator); file->header.creator=_strdup(creator); return 0; } char* SVCgetDate(SVCfile* file) { return file->header.date; } char* SVCgetFilename(SVCfile* file) { return file->header.filename; return 0; } SVCint SVCnumStates(SVCfile* file) { return file->header.numStates; } SVCint SVCnumLabels(SVCfile* file) { return file->header.numLabels; } SVCint SVCnumParameters(SVCfile* file) { return file->header.numParameters; } SVCint SVCnumTransitions(SVCfile* file) { return file->header.numTransitions; } std::string SVCerror(int errnum) { /* switch (errnum) { default: */ return svcError(errnum); /* } */ } mcrl2-201210.1/3rd-party/svc/source/code.cpp000664 001751 001751 00000014102 12042421220 021450 0ustar00jenkinsjenkins000000 000000 /* SVC -- the SVC (Systems Validation Centre) file format library Copyright (C) 2000 Stichting Mathematisch Centrum, Amsterdam, The Netherlands This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include #include #include BitStream* BSinit(FILE* fp) { BitStream* bs; bs=(BitStream*)malloc(sizeof(BitStream)); bs->numBits=0; bs->buffer='\0'; bs->fp=fp; return bs; } void BSfree(BitStream* bs) { fclose(bs->fp); free(bs); } int BSreadBit(BitStream* bs, Bit* bit) { int b; if (bs->numBits==0) { if ((b=getc(bs->fp))==EOF) { return 0; } else { bs->buffer=b; bs->numBits=8; /* fprintf(stderr, "Reading %02X\n", bs->buffer); */ } } bs->numBits--; *bit=(bs->buffer>>bs->numBits)&0x01; /* fprintf(stderr,"BSreadBit %1d (%d)\n", *bit, bs->numBits); */ return 1; } void BSwriteBit(BitStream* bs, Bit bit) { /* fprintf(stderr,"BSwriteBit %1d (%d)\n", bit, bs->numBits); */ bs->buffer<<=1; bs->buffer|=((Byte)bit); bs->numBits++; if (bs->numBits==8) { /* fprintf(stderr, "Writing %02X\n", bs->buffer); */ putc(bs->buffer,bs->fp); bs->numBits=0; bs->buffer='\0'; } } void BSwriteChar(BitStream* bs, char c) { /* Drop the most significant bit */ BSwriteBit(bs, (c>>6)&0x01); BSwriteBit(bs, (c>>5)&0x01); BSwriteBit(bs, (c>>4)&0x01); BSwriteBit(bs, (c>>3)&0x01); BSwriteBit(bs, (c>>2)&0x01); BSwriteBit(bs, (c>>1)&0x01); BSwriteBit(bs, (c>>0)&0x01); } void BSwriteByte(BitStream* bs, Byte byte) { /* fprintf(stderr, "Writing %02X\n", byte); */ BSwriteBit(bs, (byte>>7)&0x01); BSwriteBit(bs, (byte>>6)&0x01); BSwriteBit(bs, (byte>>5)&0x01); BSwriteBit(bs, (byte>>4)&0x01); BSwriteBit(bs, (byte>>3)&0x01); BSwriteBit(bs, (byte>>2)&0x01); BSwriteBit(bs, (byte>>1)&0x01); BSwriteBit(bs, (byte>>0)&0x01); } int BSreadChar(BitStream* bs, char* c) { Bit b6,b5,b4,b3,b2,b1,b0; if (BSreadBit(bs, &b6) && BSreadBit(bs, &b5) && BSreadBit(bs, &b4) && BSreadBit(bs, &b3) && BSreadBit(bs, &b2) && BSreadBit(bs, &b1) && BSreadBit(bs, &b0)) { *c=b6<<6|b5<<5|b4<<4|b3<<3|b2<<2|b1<<1|b0; /* fprintf(stderr,"BSreadChar %c\n", *c); */ return 1; } else { return 0; } } int BSreadByte(BitStream* bs, Byte* byte) { Bit b7,b6,b5,b4,b3,b2,b1,b0; if (BSreadBit(bs, &b7) && BSreadBit(bs, &b6) && BSreadBit(bs, &b5) && BSreadBit(bs, &b4) && BSreadBit(bs, &b3) && BSreadBit(bs, &b2) && BSreadBit(bs, &b1) && BSreadBit(bs, &b0)) { *byte=b7<<7|b6<<6|b5<<5|b4<<4|b3<<3|b2<<2|b1<<1|b0; /* fprintf(stderr, "Reading %02X\n", *byte); */ return 1; } else { return 0; } } void BSwriteString(BitStream* bs, const char* str) { /* fprintf(stderr, "STRING %s\n", str); */ while (*str!='\0') { BSwriteChar(bs,*(str++)); } BSwriteChar(bs,'\0'); } int BSreadString(BitStream* bs, char* str) { do { if (BSreadChar(bs,str)==0) { return 0; } } while (*(str++)!='\0'); return 1; } void BSwriteInt(BitStream* bs, long n) { Byte b0, b1, b2, b3; /* fprintf(stderr,"BSwriteInt %ld\n", n); */ if (n==NO_INT) { /* The invalid integer is represented as -0 */ BSwriteBit(bs, 1); BSwriteBit(bs, 0); BSwriteBit(bs, 0); BSwriteByte(bs, 0); } else { /* Write the sign bit */ if (n>=0) { BSwriteBit(bs, 0); } else { BSwriteBit(bs, 1); n=-n; } /* Write the two length bits and the data bytes */ b0=n%256; n/=256; if (n==0L) { BSwriteBit(bs, 0); BSwriteBit(bs, 0); BSwriteByte(bs, b0); } else { b1=n%256; n/=256; if (n==0L) { BSwriteBit(bs, 0); BSwriteBit(bs, 1); BSwriteByte(bs, b1); BSwriteByte(bs, b0); } else { b2=n%256; n/=256; if (n==0L) { BSwriteBit(bs, 1); BSwriteBit(bs, 0); BSwriteByte(bs, b2); BSwriteByte(bs, b1); BSwriteByte(bs, b0); } else { b3=n%256; n/=256; BSwriteBit(bs, 1); BSwriteBit(bs, 1); BSwriteByte(bs, b3); BSwriteByte(bs, b2); BSwriteByte(bs, b1); BSwriteByte(bs, b0); } } } } } int BSreadInt(BitStream* bs, long* n) { Bit b0, b1, s; Byte byte; BSreadBit(bs,&s); BSreadBit(bs,&b0); BSreadBit(bs,&b1); BSreadByte(bs, &byte); *n=(long)byte; if (b0==0) { if (b1==1) { BSreadByte(bs, &byte); *n=256*(*n)+byte; } else { if (s==1 && *n==0) { *n=NO_INT; } } } else { BSreadByte(bs, &byte); *n=256*(*n)+byte; BSreadByte(bs, &byte); *n=256*(*n)+byte; if (b1==1) { BSreadByte(bs, &byte); *n=256*(*n)+byte; } } if (s==1 && *n!=NO_INT) { *n=-*n; } /* fprintf(stderr,"BSreadInt %ld\n", *n); */ return 1; } void BSflush(BitStream* bs) { if (bs->numBits>0) { fprintf(bs->fp, "%c", bs->buffer<<(8-bs->numBits)); bs->numBits=0; } } int BSseek(BitStream* bs, long offset, int whence) { return fseek(bs->fp, offset, whence); } long BStell(BitStream* bs) { return ftell(bs->fp); } mcrl2-201210.1/3rd-party/svc/LICENSE000664 001751 001751 00000063637 12042421220 017560 0ustar00jenkinsjenkins000000 000000 GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 Copyright (C) 1991, 1999 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the Lesser GPL. It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it. You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below. When we speak of free software, we are referring to freedom of use, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things. To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it. And you must show them these terms so they know their rights. We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library. To protect each distributor, we want to make it very clear that there is no warranty for the free library. Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others. Finally, software patents pose a constant threat to the existence of any free program. We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder. Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License. This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License. We use this license for certain libraries in order to permit linking those libraries into non-free programs. When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library. The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom. The Lesser General Public License permits more lax criteria for linking other code with the library. We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License. It also provides other free software developers Less of an advantage over competing non-free programs. These disadvantages are the reason we use the ordinary General Public License for many libraries. However, the Lesser license provides advantages in certain special circumstances. For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard. To achieve this, non-free programs must be allowed to use the library. A more frequent case is that a free library does the same job as widely used non-free libraries. In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License. In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software. For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system. Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, whereas the latter must be combined with the library in order to run. GNU LESSER GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with. c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker. , 1 April 1990 Ty Coon, President of Vice That's all there is to it! mcrl2-201210.1/3rd-party/dparser/lr.c000775 001751 001751 00000022065 12042421220 020172 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ #include "d.h" #define INITIAL_ALLITEMS 3359 #define item_hash(_i) \ (((uint)(_i)->rule->index << 8) + \ ((uint)((_i)->kind != ELEM_END ? (_i)->index : (_i)->rule->elems.n))) static int insert_item(State *s, Elem *e) { Item *i = e; if (set_add(&s->items_hash, i)) { vec_add(&s->items, i); return 1; } return 0; } static int itemcmp(const void *ai, const void *aj) { uint i = item_hash(*(Item**)ai); uint j = item_hash(*(Item**)aj); return (i > j) ? 1 : ((i < j) ? -1 : 0); } static State * new_state() { State *s = MALLOC(sizeof(State)); memset(s, 0, sizeof(State)); return s; } static void free_state(State *s) { vec_free(&s->items); vec_free(&s->items_hash); FREE(s); } static State * maybe_add_state(Grammar *g, State *s) { int i, j; for (i = 0; i < g->states.n; i++) { if (s->hash == g->states.v[i]->hash && s->items.n == g->states.v[i]->items.n) { for (j = 0; j < s->items.n; j++) if (s->items.v[j] != g->states.v[i]->items.v[j]) goto Lcont; free_state(s); return g->states.v[i]; Lcont:; } } s->index = g->states.n; vec_add(&g->states, s); return s; } static Elem * next_elem(Item *i) { if (i->index + 1 >= i->rule->elems.n) return i->rule->end; else return i->rule->elems.v[i->index + 1]; } static State * build_closure(Grammar *g, State *s) { int j, k; for (j = 0; j < s->items.n; j++) { Item *i = s->items.v[j]; Elem *e = i; if (e->kind == ELEM_NTERM) { Production *pp = e->e.nterm; for (k = 0; k < e->e.nterm->rules.n; k++) insert_item(s, pp->rules.v[k]->elems.v ? pp->rules.v[k]->elems.v[0] : pp->rules.v[k]->end); } } qsort(s->items.v, s->items.n, sizeof(Item*), itemcmp); s->hash = 0; for (j = 0; j < s->items.n; j++) s->hash += item_hash(s->items.v[j]); return maybe_add_state(g, s); } static Elem * clone_elem(Elem *e) { Elem *ee = MALLOC(sizeof(*ee)); memcpy(ee, e, sizeof(*ee)); return ee; } static void add_goto(State *s, State *ss, Elem *e) { Goto *g = MALLOC(sizeof(Goto)); g->state = ss; g->elem = clone_elem(e); vec_add(&s->gotos, g); } static void build_state_for(Grammar *g, State *s, Elem *e) { int j; Item *i; State *ss = NULL; for (j = 0; j < s->items.n; j++) { i = s->items.v[j]; if (i->kind != ELEM_END && i->kind == e->kind && i->e.term_or_nterm == e->e.term_or_nterm) { if (!ss) ss = new_state(); insert_item(ss, next_elem(i)); } } if (ss) add_goto(s, build_closure(g, ss), e); } static void build_new_states(Grammar *g) { int i, j; State *s; Elem e; for (i = 0; i < g->states.n; i++) { s = g->states.v[i]; for (j = 0; j < g->terminals.n; j++) { e.kind = ELEM_TERM; e.e.term = g->terminals.v[j]; build_state_for(g, s, &e); } for (j = 0; j < g->productions.n; j++) { e.kind = ELEM_NTERM; e.e.nterm = g->productions.v[j]; build_state_for(g, s, &e); } } } static void build_states_for_each_production(Grammar *g) { int i; for (i = 0; i < g->productions.n; i++) if (!g->productions.v[i]->internal && g->productions.v[i]->elem) { State *s = new_state(); insert_item(s, g->productions.v[i]->elem); g->productions.v[i]->state = build_closure(g, s); } } uint elem_symbol(Grammar *g, Elem *e) { if (e->kind == ELEM_NTERM) return e->e.nterm->index; else return g->productions.n + e->e.term->index; } static int gotocmp(const void *aa, const void *bb) { Goto *a = *(Goto **)aa, *b = *(Goto **)bb; int i = a->state->index, j = b->state->index; return ((i > j) ? 1 : ((i < j) ? -1 : 0)); } static void sort_Gotos(Grammar *g) { int i; for (i = 0; i < g->states.n; i++) { VecGoto *vg = &g->states.v[i]->gotos; qsort(vg->v, vg->n, sizeof(Goto*), gotocmp); } } static void build_LR_sets(Grammar *g) { State *s = new_state(); insert_item(s, g->productions.v[0]->rules.v[0]->elems.v[0]); build_closure(g, s); build_states_for_each_production(g); build_new_states(g); sort_Gotos(g); } static Action * new_Action(Grammar *g, int akind, Term *aterm, Rule *arule, State *astate) { Action *a = MALLOC(sizeof(Action)); memset(a, 0, sizeof(Action)); a->kind = akind; a->term = aterm; a->rule = arule; a->state = astate; a->index = g->action_count++; vec_add(&g->actions, a); return a; } void free_Action(Action *a) { if (a->temp_string) FREE(a->temp_string); FREE(a); } static void add_action(Grammar *g, State *s, int akind, Term *aterm, Rule *arule, State *astate) { int i; Action *a; if (akind == ACTION_REDUCE) { /* eliminate duplicates */ for (i = 0; i < s->reduce_actions.n; i++) if (s->reduce_actions.v[i]->rule == arule) return; a = new_Action(g, akind, aterm, arule, astate); vec_add(&s->reduce_actions, a); } else { /* eliminate duplicates */ for (i = 0; i < s->shift_actions.n; i++) if (s->shift_actions.v[i]->term == aterm && s->shift_actions.v[i]->state == astate && s->shift_actions.v[i]->kind == akind) return; a = new_Action(g, akind, aterm, arule, astate); vec_add(&s->shift_actions, a); } } static void init_LR(Grammar *g) { g->action_count = 0; } static int actioncmp(const void *aa, const void *bb) { Action *a = *(Action **)aa, *b = *(Action **)bb; int i, j; if (a->kind == ACTION_SHIFT_TRAILING) i = a->term->index + 11000000; else if (a->kind == ACTION_SHIFT) i = a->term->index + 1000000; else i = a->rule->index; if (b->kind == ACTION_SHIFT_TRAILING) j = b->term->index + 11000000; else if (b->kind == ACTION_SHIFT) j = b->term->index + 1000000; else j = b->rule->index; return ((i > j) ? 1 : ((i < j) ? -1 : 0)); } void sort_VecAction(VecAction *v) { qsort(v->v, v->n, sizeof(Action*), actioncmp); } static void build_actions(Grammar *g) { int x, y, z; State *s; Elem *e; for (x = 0; x < g->states.n; x++) { s = g->states.v[x]; for (y = 0; y < s->items.n; y++) { e = s->items.v[y]; if (e->kind != ELEM_END) { if (e->kind == ELEM_TERM) { for (z = 0; z < s->gotos.n; z++) { if (s->gotos.v[z]->elem->e.term == e->e.term) add_action(g, s, ACTION_SHIFT, e->e.term, 0, s->gotos.v[z]->state); } } } else if (e->rule->prod->index) add_action(g, s, ACTION_REDUCE, NULL, e->rule, 0); else s->accept = 1; } sort_VecAction(&s->shift_actions); sort_VecAction(&s->reduce_actions); } } State * goto_State(State *s, Elem *e) { int i; for (i = 0; i < s->gotos.n; i++) if (s->gotos.v[i]->elem->e.term_or_nterm == e->e.term_or_nterm) return s->gotos.v[i]->state; return NULL; } static Hint * new_Hint(uint d, State *s, Rule *r) { Hint *h = MALLOC(sizeof(*h)); h->depth = d; h->state = s; h->rule = r; return h; } static int hintcmp(const void *ai, const void *aj) { Hint *i = *(Hint**)ai; Hint *j = *(Hint**)aj; return (i->depth > j->depth) ? 1 : ( (i->depth < j->depth) ? -1 : ( (i->rule->index > j->rule->index) ? 1 : ( (i->rule->index < j->rule->index) ? -1 : 0))); } static void build_right_epsilon_hints(Grammar *g) { int x, y, z; State *s, *ss; Elem *e; Rule *r; for (x = 0; x < g->states.n; x++) { s = g->states.v[x]; for (y = 0; y < s->items.n; y++) { e = s->items.v[y]; r = e->rule; if (e->kind != ELEM_END) { for (z = e->index; z < r->elems.n; z++) { if ((r->elems.v[z]->kind != ELEM_NTERM || !r->elems.v[z]->e.nterm->nullable)) goto Lnext; } ss = s; for (z = e->index; z < r->elems.n; z++) ss = goto_State(ss, r->elems.v[z]); if (ss && r->elems.n) vec_add(&s->right_epsilon_hints, new_Hint(r->elems.n - e->index - 1, ss, r)); else /* ignore for states_for_each_productions */; } Lnext:; } if (s->right_epsilon_hints.n > 1) qsort(s->right_epsilon_hints.v, s->right_epsilon_hints.n, sizeof(Hint*), hintcmp); } } static void build_error_recovery(Grammar *g) { int i, j, k, depth; State *s; Rule *r, *rr; Elem *e, *ee; for (i = 0; i < g->states.n; i++) { s = g->states.v[i]; for (j = 0; j < s->items.n; j++) { r = s->items.v[j]->rule; if (r->elems.n > 1 && r->elems.v[r->elems.n - 1]->kind == ELEM_TERM && r->elems.v[r->elems.n - 1]->e.term->kind == TERM_STRING) { depth = s->items.v[j]->index; e = r->elems.v[r->elems.n - 1]; for (k = 0; k < s->error_recovery_hints.n; k++) { rr = s->error_recovery_hints.v[k]->rule; ee = rr->elems.v[rr->elems.n - 1]; if (e->e.term->string_len == ee->e.term->string_len && !strcmp(e->e.term->string, ee->e.term->string)) { if (s->error_recovery_hints.v[k]->depth > depth) s->error_recovery_hints.v[k]->depth = depth; goto Ldone; } } vec_add(&s->error_recovery_hints, new_Hint(depth, NULL, r)); Ldone:; } } qsort(s->error_recovery_hints.v, s->error_recovery_hints.n, sizeof(Hint*), hintcmp); } } void build_LR_tables(Grammar *g) { init_LR(g); build_LR_sets(g); build_actions(g); build_right_epsilon_hints(g); build_error_recovery(g); } mcrl2-201210.1/3rd-party/dparser/arg.c000775 001751 001751 00000012753 12042421220 020331 0ustar00jenkinsjenkins000000 000000 /* Copyright 1994-2004 John Plevyak, All Rights Reserved */ #include "d.h" static char *SPACES = " "; static char *arg_types_keys = (char *)"ISDfF+TL"; static char *arg_types_desc[] = { (char *)"int ", (char *)"string ", (char *)"double ", (char *)"set off ", (char *)"set on ", (char *)"incr ", (char *)"toggle ", (char *)"int64 ", (char *)" " }; void process_arg(ArgumentState *arg_state, int i, char ***argv) { char * arg = NULL; ArgumentDescription *desc = arg_state->desc; if (desc[i].type) { char type = desc[i].type[0]; if (type=='F'||type=='f') *(int *)desc[i].location = type=='F'?1:0; else if (type=='T') *(int *)desc[i].location = !*(int *)desc[i].location; else if (type == '+') (*(int *)desc[i].location)++; else { arg = *++(**argv) ? **argv : *++(*argv); if (!arg) usage(arg_state, NULL); switch (type) { case 'I': *(int *)desc[i].location = atoi(arg); break; case 'D': *(double *)desc[i].location = atof(arg); break; case 'L': *(int64 *)desc[i].location = atoll(arg); break; case 'S': strncpy((char *)desc[i].location,arg, atoi(desc[i].type+1)); break; default: fprintf(stderr, "%s:bad argument description\n", arg_state->program_name); exit(1); break; } **argv += strlen(**argv)-1; } } if (desc[i].pfn) desc[i].pfn(arg_state, arg); } void process_args(ArgumentState *arg_state, char **argv) { int i = 0, len; char *end; ArgumentDescription *desc = arg_state->desc; /* Grab Environment Variables */ for (i = 0;; i++) { if (!desc[i].name) break; if (desc[i].env) { char type = desc[i].type[0]; char * env = getenv(desc[i].env); if (!env) continue; switch (type) { case 'A': case 'f': case 'F': break; case 'I': *(int *)desc[i].location = strtol(env, NULL, 0); break; case 'D': *(double *)desc[i].location = strtod(env, NULL); break; case 'L': *(int64 *)desc[i].location = strtoll(env, NULL, 0); break; case 'S': strncpy((char *)desc[i].location,env, strtol(desc[i].type+1, NULL, 0)); break; } if (desc[i].pfn) desc[i].pfn(arg_state, env); } } /* Grab Command Line Arguments */ arg_state->program_name = argv[0]; while ( *++argv ) { if ( **argv == '-' ) { if ((*argv)[1] == '-') { for (i = 0;; i++) { if (!desc[i].name) usage(arg_state,NULL); if ((end = strchr((*argv)+2, '='))) len = end - ((*argv) + 2); else len = strlen((*argv) + 2); if (len == strlen(desc[i].name) && !strncmp(desc[i].name,(*argv)+2, len)) { if (!end) *argv += strlen(*argv) - 1; else *argv = end; process_arg(arg_state, i, &argv); break; } } } else { while (*++(*argv)) for (i = 0;; i++) { if (!desc[i].name) usage(arg_state, NULL); if (desc[i].key == **argv) { process_arg(arg_state, i, &argv); break; } } } } else { arg_state->file_argument = (char **)REALLOC( arg_state->file_argument, sizeof(char**) * (arg_state->nfile_arguments + 2)); arg_state->file_argument[arg_state->nfile_arguments++] = *argv; arg_state->file_argument[arg_state->nfile_arguments] = NULL; } } } void usage(ArgumentState *arg_state, char *arg_unused) { ArgumentDescription *desc = arg_state->desc; int i; (void)arg_unused; fprintf(stderr,"Usage: %s [flags|args]\n",arg_state->program_name); for (i = 0;; i++) { if (!desc[i].name) break; if (!desc[i].description) continue; fprintf(stderr," %c%c%c --%s%s%s", desc[i].key != ' ' ? '-' : ' ', desc[i].key, desc[i].key != ' ' ? ',' : ' ', desc[i].name, (strlen(desc[i].name) + 61 < 81) ? &SPACES[strlen(desc[i].name)+61] : "", arg_types_desc[desc[i].type?strchr(arg_types_keys,desc[i].type[0])- arg_types_keys : strlen(arg_types_keys)]); switch(desc[i].type?desc[i].type[0]:0) { case 0: fprintf(stderr, " "); break; case 'L': fprintf(stderr, #ifdef __alpha " %-9ld", #else #ifdef FreeBSD " %-9qd", #else #ifdef __MINGW32__ " %-9I64d", #else " %-9lld", #endif #endif #endif *(int64*)desc[i].location); break; case 'S': if (*(char*)desc[i].location) { if (strlen((char*)desc[i].location) < 10) fprintf(stderr, " %-9s", (char*)desc[i].location); else { ((char*)desc[i].location)[7] = 0; fprintf(stderr, " %-7s..", (char*)desc[i].location); } } else fprintf(stderr, " (null) "); break; case 'D': fprintf(stderr, " %-9.3e", *(double*)desc[i].location); break; case '+': case 'I': fprintf(stderr, " %-9d", *(int *)desc[i].location); break; case 'T': case 'f': case 'F': fprintf(stderr, " %-9s", *(int *)desc[i].location?"true ":"false"); break; } fprintf(stderr," %s\n",desc[i].description); } exit(1); } void free_args(ArgumentState *arg_state) { if (arg_state->file_argument) FREE(arg_state->file_argument); } mcrl2-201210.1/3rd-party/dparser/scan.c000775 001751 001751 00000010314 12042421220 020473 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ #include "d.h" int scan_buffer(d_loc_t *aloc, D_State *parse_state, ShiftResult *results) { d_loc_t loc = *aloc, last_loc = *aloc; char *s = loc.s; int col = loc.col, line = loc.line; int nresults = 0, i = 0, j; D_Shift **shift = NULL, **shift_diff = 0; switch (parse_state->scanner_size) { case 1: { /* all matches */ SB_uint8 *st = (SB_uint8*)parse_state->scanner_table; SB_trans_uint8 *tst = (SB_trans_uint8*)parse_state->transition_table; uint8 state = 0, last = state, prev = state; uint8 c; uint32 sb, so; c = (uint8)*s++; while ((state = st[state].scanner_block[(sb = (c >> SCANNER_BLOCK_SHIFT))] [(so = c & SCANNER_BLOCK_MASK)])) { state -= 1; if (prev && parse_state->accepts_diff) { shift_diff = parse_state->accepts_diff[tst[prev].scanner_block[sb][so]]; for (; *shift_diff; shift_diff++) { results[nresults].loc = loc; results[nresults++].shift = *shift_diff; } } prev = state; if (c == '\n') { line++; col = 0; } else col++; loc.s = s; loc.line = line; loc.col = col; if (st[state].shift) { last = state; last_loc = loc; } c = (uint8)*s++; } shift = st[last].shift; break; } case 2: { /* all matches */ SB_uint16 *st = (SB_uint16*)parse_state->scanner_table; SB_trans_uint16 *tst = (SB_trans_uint16*)parse_state->transition_table; uint16 state = 0, last = state, prev = state; uint8 c; uint32 sb, so; c = (uint8)*s++; while ((state = st[state].scanner_block[(sb = (c >> SCANNER_BLOCK_SHIFT))] [(so = c & SCANNER_BLOCK_MASK)])) { state -= 1; if (prev && parse_state->accepts_diff) { shift_diff = parse_state->accepts_diff[tst[prev].scanner_block[sb][so]]; for (; *shift_diff; shift_diff++) { results[nresults].loc = loc; results[nresults++].shift = *shift_diff; } } prev = state; loc.s = s; loc.line = line; loc.col = col; if (st[state].shift) { last = state; last_loc = loc; } if (c == '\n') { line++; col = 0; } else col++; c = (uint8)*s++; } shift = st[last].shift; break; } case 4: { /* all matches */ SB_uint32 *st = (SB_uint32*)parse_state->scanner_table; SB_trans_uint32 *tst = (SB_trans_uint32*)parse_state->transition_table; uint32 state = 0, last = state, prev = state; uint8 c; uint32 sb, so; c = (uint8)*s++; while ((state = st[state].scanner_block[(sb = (c >> SCANNER_BLOCK_SHIFT))] [(so = c & SCANNER_BLOCK_MASK)])) { state -= 1; if (prev && parse_state->accepts_diff) { shift_diff = parse_state->accepts_diff[tst[prev].scanner_block[sb][so]]; for (; *shift_diff; shift_diff++) { results[nresults].loc = loc; results[nresults++].shift = *shift_diff; } } prev = state; loc.s = s; loc.line = line; loc.col = col; if (st[state].shift) { last = state; last_loc = loc; } if (c == '\n') { line++; col = 0; } else col++; c = (uint8)*s++; } shift = st[last].shift; break; } } if (shift) { for (; *shift; shift++) { results[nresults].loc = last_loc; results[nresults++].shift = *shift; } } if (nresults) { int longest = 0; char *end = results[nresults-1].loc.s; if (parse_state->scan_kind == D_SCAN_LONGEST) longest = 1; if (parse_state->scan_kind == D_SCAN_MIXED) { for (i = nresults - 1; i >= 0; i--) { if (results[i].loc.s < end) break; if (results[i].shift->shift_kind == D_SCAN_LONGEST) longest = 1; } } if (longest) { /* keep only 'longest' */ i = 0; for (j = 0; j < nresults; j++) { if (results[j].loc.s == end || results[j].shift->shift_kind == D_SCAN_TRAILING) { if (i != j) results[i] = results[j]; i++; } } nresults = i; } else if (parse_state->scan_kind == D_SCAN_MIXED) { /* only keep non-longest */ for (j = i; j >= 0; j--) if (results[j].shift->shift_kind != D_SCAN_LONGEST) { if (i != j) results[i] = results[j]; i--; } nresults = nresults - i - 1; if (i != -1) memmove(&results[0], &results[i + 1], nresults * sizeof(results[0])); } } return nresults; } mcrl2-201210.1/3rd-party/dparser/mkdparse.h000775 001751 001751 00000000532 12042421220 021363 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ #ifndef _mkdparse_H_ #define _mkdparse_H_ #include #if defined(__cplusplus) extern "C" { #endif struct Grammar; void mkdparse(struct Grammar *g, char *grammar_pathname); void mkdparse_from_string(struct Grammar *g, char *str); #if defined(__cplusplus) } #endif #endif mcrl2-201210.1/3rd-party/dparser/util.c000775 001751 001751 00000017234 12042421220 020534 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2006 John Plevyak, All Rights Reserved */ #include "d.h" uint d_prime2[] = { 1, 3, 7, 13, 31, 61, 127, 251, 509, 1021, 2039, 4093, 8191, 16381, 32749, 65521, 131071, 262139, 524287, 1048573, 2097143, 4194301, 8388593, 16777213, 33554393, 67108859, 134217689, 268435399, 536870909 }; int d_verbose_level = 0; int d_debug_level = 0; int test_level = 0; int d_rdebug_grammar_level = 0; char * d_dup_pathname_str(const char *s) { const char *e = s; if (!s) return dup_str("", 0); if (*e == '"') { e++; while (*e && *e != '"') e++; return dup_str(s + 1, e); } else return dup_str(s, s+strlen(s)); } char * dup_str(const char *s, const char *e) { int l = e ? e-s : strlen(s); char *ss = (char*)MALLOC(l+1); memcpy(ss, s, l); ss[l] = 0; return ss; } uint strhashl(const char *s, int l) { uint h = 0, g; int i = 0; for (;i < l;i++,s++) { h = (h << 4) + *s; if ((g = h & 0xf0000000)) h = (h ^ (g >> 24)) ^ g; } return h; } int buf_read(const char *pathname, char **buf, int *len) { struct stat sb; int fd; size_t real_size; *buf = 0; *len = 0; fd = open(pathname, O_RDONLY); if (fd <= 0) return -1; memset(&sb, 0, sizeof(sb)); fstat(fd, &sb); *len = sb.st_size; *buf = (char*)MALLOC(*len + 2); // MINGW likes to convert cr lf => lf which messes with the size real_size = read(fd, *buf, *len); (*buf)[real_size] = 0; (*buf)[real_size + 1] = 0; *len = real_size; close(fd); return *len; } char * sbuf_read(const char *pathname) { char *buf; int len; if (buf_read(pathname, &buf, &len) < 0) return NULL; return buf; } void d_fail(const char *str, ...) { char nstr[256]; va_list ap; va_start(ap, str); snprintf(nstr, 255, "fail: %s\n", str); vfprintf(stderr, nstr, ap); va_end(ap); exit(1); } void d_warn(const char *str, ...) { char nstr[256]; va_list ap; va_start(ap, str); snprintf(nstr, 255, "warning: %s\n", str); vfprintf(stderr, nstr, ap); va_end(ap); } void vec_add_internal(void *v, void *elem) { AbstractVec *av = (AbstractVec*)v; if (!av->n) { av->v = av->e; } else if (av->v == av->e) { av->v = (void**)MALLOC(INITIAL_VEC_SIZE * sizeof(void *)); memcpy(av->v, av->e, av->n * sizeof(void *)); } else { if ((av->n & (INITIAL_VEC_SIZE - 1)) == 0) { int l = av->n, nl = (1 + INITIAL_VEC_SHIFT); l = l >> INITIAL_VEC_SHIFT; while (!(l&1)) { l = l >> 1; nl++; } l = l >> 1; if (!av->n || !l) { nl = 1 << nl; av->v = (void**)REALLOC(av->v, nl * sizeof(void *)); } } } av->v[av->n] = elem; av->n++; } int vec_eq(void *v, void *vv) { AbstractVec *av = (AbstractVec*)v; AbstractVec *avv = (AbstractVec*)vv; uint i; if (av->n != avv->n) return 0; for (i = 0; i < av->n; i++) if (av->v[i] != avv->v[i]) return 0; return 1; } void * stack_push_internal(AbstractStack *s, void *elem) { int n = s->cur - s->start; if (s->start == s->initial) { s->cur = (void**)MALLOC(n * 2 * sizeof(void*)); memcpy(s->cur, s->start, n * sizeof(void*)); } else s->cur = (void**)REALLOC(s->start, n * 2 * sizeof(void*)); s->end = s->start = s->cur; s->cur += n; s->end += n * 2; *s->cur++ = elem; return elem; } int set_find(void *av, void *t) { AbstractVec *v = (AbstractVec*)av; int j, n = v->n; uint i; if (n) { uint h = ((uintptr_t)t); h = h % n; for (i = h, j = 0; i < v->n && j < SET_MAX_SEQUENTIAL; i = ((i + 1) % n), j++) { if (!v->v[i]) { return 0; } else if (v->v[i] == t) return 1; } } return 0; } int set_add(void *av, void *t) { AbstractVec *v = (AbstractVec*)av, vv; int j, n = v->n; uint i; if (n) { uint h = ((uintptr_t)t); h = h % n; for (i = h, j = 0; i < v->n && j < SET_MAX_SEQUENTIAL; i = ((i + 1) % n), j++) { if (!v->v[i]) { v->v[i] = t; return 1; } else if (v->v[i] == t) return 0; } } if (!n) { vv.v = NULL; v->i = INITIAL_SET_SIZE_INDEX; } else { vv.v = v->v; vv.n = v->n; v->i = v->i + 1; } v->n = d_prime2[v->i]; v->v = (void**)MALLOC(v->n * sizeof(void *)); memset(v->v, 0, v->n * sizeof(void *)); if (vv.v) { set_union(av, &vv); FREE(vv.v); } return set_add(v, t); } void * set_add_fn(void *av, void *t, hash_fns_t *fns) { AbstractVec *v = (AbstractVec*)av, vv; uint32 tt = fns->hash_fn(t, fns); int j, n = v->n; uint i; if (n) { uint h = tt % n; for (i = h, j = 0; i < v->n && j < SET_MAX_SEQUENTIAL; i = ((i + 1) % n), j++) { if (!v->v[i]) { v->v[i] = t; return t; } else { if (!fns->cmp_fn(v->v[i], t, fns)) return v->v[i]; } } } if (!n) { vv.v = NULL; v->i = INITIAL_SET_SIZE_INDEX; } else { vv.v = v->v; vv.n = v->n; v->i = v->i + 1; } v->n = d_prime2[v->i]; v->v = (void**)MALLOC(v->n * sizeof(void *)); memset(v->v, 0, v->n * sizeof(void *)); if (vv.v) { set_union_fn(av, &vv, fns); FREE(vv.v); } return set_add_fn(v, t, fns); } int set_union(void *av, void *avv) { AbstractVec *vv = (AbstractVec*)avv; uint i, changed = 0; for (i = 0; i < vv->n; i++) if (vv->v[i]) changed = set_add(av, vv->v[i]) || changed; return changed; } void set_union_fn(void *av, void *avv, hash_fns_t *fns) { AbstractVec *vv = (AbstractVec*)avv; uint i; for (i = 0; i < vv->n; i++) if (vv->v[i]) set_add_fn(av, vv->v[i], fns); } void set_to_vec(void *av) { AbstractVec *v = (AbstractVec*)av, vv; uint i; vv.n = v->n; vv.v = v->v; if (v->v == v->e) { memcpy(vv.e, v->e, sizeof(v->e)); vv.v = vv.e; } v->n = 0; v->v = 0; for (i = 0; i < vv.n; i++) if (vv.v[i]) vec_add_internal(v, vv.v[i]); FREE(vv.v); } void int_list_diff(int *a, int *b, int *c) { while (1) { if (*b < 0) break; Lagainc: if (*c < 0) { while (*b >= 0) *a++ = *b++; break; } Lagainb: if (*b == *c) { b++; c++; continue; } if (*b < *c) { *a++ = *b++; if (*b < 0) break; goto Lagainb; } if (*c < *b) { c++; goto Lagainc; } } *a++ = -1; } void int_list_intersect(int *a, int *b, int *c) { while (1) { if (*b < 0) break; Lagainc: if (*c < 0) break; Lagainb: if (*b == *c) { *a++ = *b++; c++; continue; } if (*b < *c) { b++; if (*b < 0) break; goto Lagainb; } if (*c < *b) { c++; goto Lagainc; } } *a++ = -1; } int * int_list_dup(int *aa) { int *a = aa, *b, *bb; while (*a != -1) { a++; } bb = b = (int*)MALLOC((a - aa + 1) * sizeof(int)); a = aa; while (*a != -1) { *b++ = *a++; } *b++ = -1; return bb; } #define ESC(_c) *ss++ = '\\'; *ss++ = _c; break; static char * escape_string_internal(char *s, int single_quote) { char *ss = (char*)MALLOC((strlen(s) + 1) * 4), *sss = ss; for (; *s; s++) { switch (*s) { case '\b': ESC('b'); case '\f': ESC('f'); case '\n': ESC('n'); case '\r': ESC('r'); case '\t': ESC('t'); case '\v': ESC('v'); case '\a': ESC('a'); case '\\': ESC('\\'); case '\"': if (!single_quote) { ESC(*s); } *ss++ = *s; break; case '\'': if (single_quote) { ESC(*s); } *ss++ = *s; break; default: if (isprint_(*s)) *ss++ = *s; else { *ss++ = '\\'; *ss++ = 'x'; *ss++ = tohex2((unsigned char)*s); *ss++ = tohex1((unsigned char)*s); } break; } } *ss = 0; return sss; } char *escape_string(char *s) { return escape_string_internal(s, 0); } char *escape_string_single_quote(char *s) { return escape_string_internal(s, 1); } void d_free(void *x) { FREE(x); } mcrl2-201210.1/3rd-party/dparser/README000775 001751 001751 00000001226 12042421220 020265 0ustar00jenkinsjenkins000000 000000 This is DParser, a scannerless GLR parser. It uses to Tomita algorithm, and incorporates BNF production syntax, regular expression terminals, and a state-specific symbol table. It can be compiled to work with or without the Boehm Garbage Collector. To compile with GC, uncomment the line D_USE_GC=1 in the Makefile. The result is natural grammars and powerful parsing. To build: 'gmake' (only available with source code package) To test: 'gmake test' (only available with source code package) To install: 'gmake install' (binary or source code packages) For python support, '(cd python; gmake install)' Refer to the manual for more information. mcrl2-201210.1/3rd-party/dparser/CHANGES000775 001751 001751 00000013157 12042421220 020406 0ustar00jenkinsjenkins000000 000000 1.28 Fixed bug with actions containing commments containing ' Python 2.6+ support, thanx to jonas@lophus.org 1.27 Fixed error with input ending on C++ style comment (thanx voiz) 1.26 Unicode fix thanx to agsags Fixed some compilation warnings 1.25 Fix const issues thanx to Harald Gutsche Fix MINGW issue where it lies about the size of a file 1.24 Fixed bug in with -R option Prevented substitutions in strings in code 1.23 Whitespace parsers now inherit attriutes of the parent Fixed (another) error recovery crash bug Add ability to disable freelists for better valgrind results 1.22 Add ambiguity callbacks for python (Humberto Abdelnur) Fixed error recovery crash bug Fixed column number bug. Fixed missing column and line numbers when using a whitespace subparser. 1.21 Fix 2 issues with documentation (Holger Waechtler) 1.20 Fixed a couple Verilog issues (thanx to Brian Pharris) Python Unicode support (thanx to Simon Law) Added disabiguation switches to test_parser Fixed potential hang in Error Recovery Warning free under GCC 4.3.2 Use struct for location in callbacks (thanx to Holger Waechtler) 1.19 Fixed memory leak (thanx Humberto Abdelnur) Updated to current SWIG (thanx Humberto Abdelnur) Added support for repeating elements (elem@1:3) 1 to 3 times 1.18 added -o option for output file use ranlib for Darwin compatibility fixed some memory leaks fix greediness with simpler algorithm Basic unicode support 1.17 Fixed a bug which could result in incorrect actions being called 1.16 Use flag to disable strict aliasing optimizations in GCC Add options for greedy and height disambiguation 1.15 Removed call to exec in python interface (Brian Sabbey) Fix binary_op_left in python interface (Brian Sabbey) 1.14 Support generation of code from a grammar to print the parse tree instead of executing the actions (Wlodzimierz Bzyl) Support user-defined print functions (Wlodzimierz Bzyl) Support disambiguation based on greedyness (optional) Fixed a bug in the python support which prevented the use of associativity and priority Add support for 64-bit systems to the python interface 1.13 Fixed compilation issue with use of GC option. Fixed memory leak with reusing a parser with a whitespace production. Fixed a potential memory leak in the python interface. Fixed memory leaks with the mkdparser library. 1.12 Fixed some portability ANSI-C issues. Fixed a bug where actions would not fire with regex productions. Changed the binary interface ${action} placement. 1.11 Added new interfaces for binary output to memory/file Fixed bug in ambiguity handling 1.10 Fixed bug in binary output Port to x64 1.9 Fixed bug in error recovery Added support for trailing context in regex ("foo/bar") Fixed bug in longest match scanning Fixed bug in d_ws_before Use str(r)chr instead of non-standard (r)index Binary table format for python (Brian Sabbey) 1.8 Added the ability to 'include' subgrammars Add %< %> as global code indicators Add $#n for number of children of element n Add ${child 1,2,3} for 3rd child of 2nd child of 1st child Added option for fixup_EBNF_productions Changed the way fixups work to be more consistent Add naming of regex productions Add support for dynamic scoping to symtab Improved line numbering of generated code Add -I option identify grammar by filename Fixed support for very large scanners 1.7 Another fix for MINGW32 Fix to state splitting Add start_state to table of symbols Updated python interface (thanx to Brian Sabbey) Added option terminal option $name to name terminals Add option to set extension of generated code file 1.6 Fixed missing test files Fixed ${declare subparser XXX} Fixed bug with multiple passes Split states based on symboltable and globals Added print_scope 1.5 Fixed web pages Fixed DEBUG compilation error Fixed ${scan XXX} example (g4.test.g) Fixed strings/chars in ANSI-C grammar Fixed OSX/Darwin compilation Fixed ws_before/ws_after Added support for \xNN \d00 escape sequences Added support for /i (ignore case) strings/regexes Added support for starting in arbitrary states 1.4 Added embedded actions Added default actions Added support for multi-pass compilation Added support for mixed all/longest scanners Enhanced python interface 1.3 Made GC version end in _gc Fixed symtab, changed interface and added test cases Fixed other bugs Added verilog grammar Added python grammar Added support for regular expression 'productions' 1.2 Fixed a bug in cmp_reduction_priorities that could result in crashes Fixed a bug which could result in ambiguity on final result (thanx Thomas) Fixed a bug in fixup of internal reductions which could result in incorrectly ordered actions (thanx Tomas) Fixed a bug in stack comparison pruning which could result in incorrectly ruling out legal parses Added python support (thanx to Brian Sabbey) Added non-longest-match-only scanning 1.1 Fixed bug in fixing up internal productions Made the default using left recursion for EBNF internal productions 1.0 Added full unambiguous ANSI C grammar Added tokenizers (scanners shared over sets of states) Added support for subparsers Cleanup of header files Fixed bugs in error recovery 1.0b2 Improved memory utilization Fixed bug with right epsilon grammars Added simple error recovery General bug fixes 1.0b1 First release mcrl2-201210.1/3rd-party/dparser/make_dparser.c000775 001751 001751 00000011553 12042421220 022212 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ #include "gramgram.h" #include "d.h" #include "mkdparse.h" static void help(ArgumentState *arg_state, char *arg_unused); static int set_op_priority_from_rule = 0; static int right_recursive_BNF = 0; static int states_for_whitespace = 1; static int states_for_all_nterms = 0; static int tokenizer = 0; static int longest_match = 0; static char grammar_ident[256] = "gram"; static int ident_from_filename = 0; static int scanner_blocks = 4; static int scanner_block_size; static int write_line_directives = 1; static int write_header = -1; static int token_type = 0; static char write_extension[256] = "c"; static char output_file [1024] = ""; static ArgumentDescription arg_desc[] = { {"output", 'o', "Output file name", "S1024", &output_file[0], "D_MAKE_PARSER_OUTPUT", NULL}, {"longest_match", 'l', "Use Longest Match Rule for Tokens", "T", &longest_match, "D_MAKE_LONGEST_MATCH", NULL}, {"tokenizer", 'T', "Tokenizer for START", "T", &tokenizer, "D_MAKE_PARSER_TOKENIZER", NULL}, {"write_header", 'H', "Write Header (-1:if not empty)", "I", &write_header, "D_MAKE_PARSER_HEADER", NULL}, {"token_type", 't', "Token Type (0:define, 1:enum)", "I", &token_type, "D_MAKE_PARSER_TOKEN", NULL}, {"whitespace_states", 'C', "Compute Whitespace States", "T", &states_for_whitespace, "D_MAKE_PARSER_WHITESPACE", NULL}, {"all_states", 'A', "Compute States For All NTERMs", "T", &states_for_all_nterms, "D_MAKE_PARSER_ALL_NTERMS", NULL}, {"grammar_ident", 'i', "Grammar Identifier", "S255", grammar_ident, "D_MAKE_PARSER_GRAMMAR_IDENT", NULL}, {"filename_ident", 'I', "Use Filename as Identifier", "T", &ident_from_filename, "D_MAKE_PARSER_IDENT_FROM_FILENAME", NULL}, {"scanner_blocks", 'b', "Scanner Blocks", "I", &scanner_blocks, "D_MAKE_PARSER_SCANNER_BLOCKS", NULL}, {"op_pri_from_rule", 'p', "Set Operator Priority From Rule", "T", &set_op_priority_from_rule, "D_MAKE_PARSER_SET_PRIORITY", NULL}, {"right_recurse_BNF", 'r', "Use Right Recursion For */+", "T", &right_recursive_BNF, "D_MAKE_PARSER_RIGHT_RECURSIVE_BNF", NULL}, {"write_lines", 'L', "Write #line(s)", "T", &write_line_directives, "D_MAKE_PARSER_WRITE_LINE_DIRECTIVES", NULL}, {"ext", 'X', "Code file extension (e.g. cpp)", "S256", &write_extension[0], "D_MAKE_PARSER_WRITE_EXT", NULL}, {"verbose", 'v', "Verbose", "+", &d_verbose_level, "D_MAKE_PARSER_VERBOSE", NULL}, {"debug", 'd', "Debug", "+", &d_debug_level, "D_MAKE_PARSER_DEBUG", NULL}, {"rdebug_grammar", 'R', "Replace actions with ones printing productions", "+", &d_rdebug_grammar_level, "D_MAKE_RDEBUG_GRAMMAR", NULL}, {"help", 'h', "Help", NULL, NULL, NULL, help}, {0} }; static ArgumentState arg_state = { 0, 0, "program", arg_desc }; extern D_ParserTables parser_tables_dparser_gram; static void help(ArgumentState *arg_state, char *arg_unused) { char ver[30]; d_version(ver); fprintf(stderr, "Make DParser Version %s ", ver); fprintf(stderr, "Copyright (c) 2002-2004 John Plevyak\n"); usage(arg_state, arg_unused); } int main(int argc, char *argv[]) { char *grammar_pathname; Grammar *g; process_args(&arg_state, argv); if (arg_state.nfile_arguments != 1) help(&arg_state, NULL); grammar_pathname = arg_state.file_argument[0]; g = new_D_Grammar(grammar_pathname); /* grammar construction options */ g->set_op_priority_from_rule = set_op_priority_from_rule; g->right_recursive_BNF = right_recursive_BNF; g->states_for_whitespace = states_for_whitespace; g->states_for_all_nterms = states_for_all_nterms; g->tokenizer = tokenizer; g->longest_match = longest_match; /* grammar writing options */ strcpy(g->grammar_ident, grammar_ident); if (ident_from_filename) { char *n = strrchr(grammar_pathname, '/'), *e; n = n ? n : grammar_pathname; e = strchr(n, '.'); e = e ? e : n + strlen(n); memcpy(g->grammar_ident, n, e-n); g->grammar_ident[e-n] = 0; } g->scanner_blocks = scanner_blocks; g->scanner_block_size = scanner_block_size; g->write_line_directives = write_line_directives; g->write_header = write_header; g->token_type = token_type; strcpy(g->write_extension, write_extension); if (!output_file[0]) { strncpy(output_file, grammar_pathname, sizeof(output_file)-1); strncat(output_file, ".d_parser.", sizeof(output_file)-strlen(output_file)-1); strncat(output_file, g->write_extension, sizeof(output_file)-strlen(output_file)-1); } g->write_pathname = output_file; /* don't print anything to stdout, when the grammar is printed there */ if (d_rdebug_grammar_level > 0) d_verbose_level = 0; mkdparse(g, grammar_pathname); if (d_rdebug_grammar_level == 0) { if (write_c_tables(g) < 0) d_fail("unable to write C tables '%s'", grammar_pathname); } else print_rdebug_grammar(g, grammar_pathname); free_args(&arg_state); free_D_Grammar(g); g = 0; return 0; } mcrl2-201210.1/3rd-party/dparser/read_binary.h000775 001751 001751 00000001400 12042421220 022027 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ #ifndef _read_binary_H_ #define _read_binary_H_ typedef struct BinaryTablesHead { int n_relocs; int n_strings; int d_parser_tables_loc; int tables_size; int strings_size; } BinaryTablesHead; typedef struct BinaryTables { D_ParserTables *parser_tables_gram; char *tables; } BinaryTables; BinaryTables * read_binary_tables(char *file_name, D_ReductionCode spec_code, D_ReductionCode final_code); BinaryTables * read_binary_tables_from_file(FILE *fp, D_ReductionCode spec_code, D_ReductionCode final_code); BinaryTables * read_binary_tables_from_string(unsigned char *buf, D_ReductionCode spec_code, D_ReductionCode final_code); void free_BinaryTables(BinaryTables * binary_tables); #endif mcrl2-201210.1/3rd-party/dparser/dparse_tables.h000775 001751 001751 00000010066 12042421220 022370 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ #ifndef _dparse_tables_H_ #define _dparse_tables_H_ #define SCANNER_BLOCKS_POW2 2 #define SCANNER_BLOCKS (1 << SCANNER_BLOCKS_POW2) #define SCANNER_BLOCK_SHIFT (8 - SCANNER_BLOCKS_POW2) #define SCANNER_BLOCK_MASK ((1 << SCANNER_BLOCK_SHIFT) - 1) #define SCANNER_BLOCK_SIZE (256 / SCANNER_BLOCKS) struct D_Parser; struct D_ShiftTable; #define D_PN(_x, _o) ((D_ParseNode*)((char*)(_x) + _o)) typedef struct d_loc_t { char *s, *pathname, *ws; int col, line; } d_loc_t; typedef void (*D_WhiteSpaceFn)(struct D_Parser *p, d_loc_t *loc, void **p_globals); typedef int (*D_ScanCode)( d_loc_t *loc, unsigned short *symbol, int *term_priority, unsigned char *op_assoc, int *op_priority); typedef int (*D_ReductionCode)( void *new_ps, void **children, int n_children, int pn_offset, struct D_Parser *parser); typedef struct D_Reduction { unsigned short nelements; unsigned short symbol; D_ReductionCode speculative_code; D_ReductionCode final_code; unsigned short op_assoc; unsigned short rule_assoc; int op_priority; int rule_priority; int action_index; int npass_code; D_ReductionCode *pass_code; } D_Reduction; typedef struct D_RightEpsilonHint { unsigned short depth; unsigned short preceeding_state; D_Reduction *reduction; } D_RightEpsilonHint; typedef struct D_ErrorRecoveryHint { unsigned short depth; unsigned short symbol; const char *string; } D_ErrorRecoveryHint; typedef struct D_Shift { unsigned short symbol; unsigned char shift_kind; unsigned char op_assoc; int op_priority; int term_priority; int action_index; D_ReductionCode speculative_code; } D_Shift; typedef struct SB_uint8 { D_Shift **shift; unsigned char *scanner_block[SCANNER_BLOCKS]; } SB_uint8; typedef struct SB_uint16 { D_Shift **shift; unsigned short *scanner_block[SCANNER_BLOCKS]; } SB_uint16; typedef struct SB_uint32 { D_Shift **shift; unsigned int *scanner_block[SCANNER_BLOCKS]; } SB_uint32; typedef struct SB_trans_uint8 { unsigned char *scanner_block[SCANNER_BLOCKS]; } SB_trans_uint8; typedef struct SB_trans_uint16 { unsigned short *scanner_block[SCANNER_BLOCKS]; } SB_trans_uint16; typedef struct SB_trans_uint32 { unsigned int *scanner_block[SCANNER_BLOCKS]; } SB_trans_uint32; #define D_SCAN_ALL 0 #define D_SCAN_LONGEST 1 #define D_SCAN_MIXED 2 #define D_SCAN_TRAILING 3 #define D_SCAN_RESERVED 4 #define D_SCAN_DEFAULT D_SCAN_ALL typedef struct D_State { unsigned char *goto_valid; int goto_table_offset; struct { unsigned int n; D_Reduction **v; } reductions; struct { unsigned int n; D_RightEpsilonHint *v; } right_epsilon_hints; struct { unsigned int n; D_ErrorRecoveryHint *v; } error_recovery_hints; int shifts; D_ScanCode scanner_code; void* scanner_table; unsigned char scanner_size; unsigned char accept; unsigned char scan_kind; void* transition_table; D_Shift ***accepts_diff; int reduces_to; } D_State; #define D_SHIFTS_CODE ((D_Shift**)-1) #define D_SYMBOL_NTERM 1 #define D_SYMBOL_INTERNAL 2 #define D_SYMBOL_EBNF 3 #define D_SYMBOL_STRING 4 #define D_SYMBOL_REGEX 5 #define D_SYMBOL_CODE 6 #define D_SYMBOL_TOKEN 7 typedef struct D_Symbol { unsigned int kind; const char *name; int name_len; int start_symbol; } D_Symbol; #define D_PASS_PRE_ORDER 0x0001 #define D_PASS_POST_ORDER 0x0002 #define D_PASS_MANUAL 0x0004 #define D_PASS_FOR_ALL 0x0008 #define D_PASS_FOR_UNDEFINED 0x0010 typedef struct D_Pass { char *name; unsigned int name_len; unsigned int kind; unsigned int index; } D_Pass; typedef struct D_ParserTables { unsigned int nstates; D_State *state; unsigned short *goto_table; unsigned int whitespace_state; unsigned int nsymbols; D_Symbol *symbols; D_WhiteSpaceFn default_white_space; unsigned int npasses; D_Pass *passes; unsigned int save_parse_tree; } D_ParserTables; void parse_whitespace(struct D_Parser *p, d_loc_t *loc, void **p_globals); #endif mcrl2-201210.1/3rd-party/dparser/README.1ST000775 001751 001751 00000000314 12042421220 020670 0ustar00jenkinsjenkins000000 000000 This is a stripped version of DParser 1.26. Only the files necessary to build the parser generator and the dparser library are included, together with the original copyright notice, readme and changelog. mcrl2-201210.1/3rd-party/dparser/dsymtab.h000775 001751 001751 00000004407 12042421220 021225 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ #ifndef _dsymtab_H_ #define _dsymtab_H_ #ifndef D_UserSym #define D_UserSym unsigned int #endif struct D_SymHash; struct D_Scope; typedef struct D_Sym { char *name; int len; unsigned int hash; struct D_Scope *scope; struct D_Sym *update_of; struct D_Sym *next; D_UserSym user; } D_Sym; #define D_SCOPE_INHERIT 0 #define D_SCOPE_RECURSIVE 1 #define D_SCOPE_PARALLEL 2 #define D_SCOPE_SEQUENTIAL 3 typedef struct D_Scope { unsigned int kind:2; unsigned int owned_by_user:1; /* don't automatically delete */ unsigned int depth; D_Sym *ll; struct D_SymHash *hash; D_Sym *updates; struct D_Scope *search; /* scope to start search */ struct D_Scope *dynamic; /* dynamic scope (e.g. methods) */ struct D_Scope *up; /* enclosing scope */ struct D_Scope *up_updates; /* prior scope in speculative parse */ struct D_Scope *down; /* enclosed scopes (for FREE) */ struct D_Scope *down_next; /* next enclosed scope */ } D_Scope; D_Scope *new_D_Scope(D_Scope *parent); D_Scope *enter_D_Scope(D_Scope *current, D_Scope *scope); D_Scope *commit_D_Scope(D_Scope *scope); D_Scope *equiv_D_Scope(D_Scope *scope); D_Scope *global_D_Scope(D_Scope *scope); D_Scope *scope_D_Scope(D_Scope *current, D_Scope *scope); void free_D_Scope(D_Scope *st, int force); D_Sym *new_D_Sym(D_Scope *st, char *name, char *end, int sizeof_D_Sym); #define NEW_D_SYM(_st, _name, _end) new_D_Sym(_st, _name, _end, sizeof(D_Sym)) void free_D_Sym(D_Sym *sym); D_Sym *find_D_Sym(D_Scope *st, char *name, char *end); D_Sym *find_global_D_Sym(D_Scope *st, char *name, char *end); /* use for first update in a production to update scope */ D_Sym *update_D_Sym(D_Sym *sym, D_Scope **st, int sizeof_D_Sym); #define UPDATE_D_SYM(_sym, _st) update_D_Sym(_sym, _st, sizeof(D_Sym)) /* use for first subsequent updates in a production */ D_Sym *update_additional_D_Sym(D_Scope *st, D_Sym *sym, int sizeof_D_Sym); #define UPDATE_ADDITIONAL_D_SYM(_st, _sym) update_additional_D_Sym(_st, _sym, sizeof(D_Sym)) D_Sym *current_D_Sym(D_Scope *st, D_Sym *sym); D_Sym *find_D_Sym_in_Scope(D_Scope *st, D_Scope *cur, char *name, char *end); D_Sym *next_D_Sym_in_Scope(D_Scope **st, D_Sym **sym); void print_scope(D_Scope *st); #endif mcrl2-201210.1/3rd-party/dparser/CMakeLists.txt000775 001751 001751 00000002515 12042421220 022147 0ustar00jenkinsjenkins000000 000000 # Author: Sjoerd Cranen # Copyright: see the accompanying file COPYING or copy at # https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING # # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) # ########## Project setup ########## project(dparser) cmake_minimum_required(VERSION 2.6) add_definitions( -DD_MAJOR_VERSION=1 -DD_MINOR_VERSION=26 -DD_BUILD_VERSION="mCRL2" -DD_USE_FREELISTS=1 ) if(MSVC) add_definitions( -Dstrtoll=_strtoi64 -Dstrncasecmp=_strnicmp -Dsnprintf=_snprintf ) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /w") else(MSVC) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w") # The following is more accurate, but currently does not do the job #set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-sign-compare -Wno-unused-parameter -Wno-long-long -Wno-format") endif(MSVC) # ######### General setup ########## include_directories(${CMAKE_SOURCE_DIR}/3rd-party/dparser) # actual target: add_library(dparser arg.c parse.c scan.c symtab.c util.c read_binary.c dparse_tree.c ) add_executable(make_dparser make_dparser.c version.c mkdparse.c write_tables.c grammar.g.c gram.c lex.c lr.c ) target_link_libraries(make_dparser dparser ) install(TARGETS dparser DESTINATION ${MCRL2_LIB_DIR} COMPONENT Libraries) mcrl2-201210.1/3rd-party/dparser/parse.h000775 001751 001751 00000006723 12042421220 020677 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ #ifndef _parse_H_ #define _parse_H_ #define NO_DPN ((D_ParseNode*)0x1) #define DPN_TO_PN(_dpn) \ ((PNode *)(((char*)dpn)-(intptr_t)(&((PNode*)0)->parse_node))) #define is_epsilon_PNode(_pn) \ ((_pn)->parse_node.start_loc.s == (_pn)->parse_node.end) /* #define TRACK_PNODES 1 */ struct PNode; struct SNode; struct ZNode; struct Parser; typedef Vec(struct ZNode*) VecZNode; typedef Vec(VecZNode *) VecVecZNode; typedef Vec(struct SNode*) VecSNode; typedef Vec(struct PNode*) VecPNode; typedef struct PNodeHash { struct PNode **v; uint i; /* size index (power of 2) */ uint m; /* max size (highest prime < i ** 2) */ uint n; /* size */ struct PNode *all; } PNodeHash; typedef struct SNodeHash { struct SNode **v; uint i; /* size index (power of 2) */ uint m; /* max size (highest prime < i ** 2) */ uint n; /* size */ struct SNode *all; struct SNode *last_all; } SNodeHash; typedef struct Reduction { struct ZNode *znode; struct SNode *snode; struct D_Reduction *reduction; struct SNode *new_snode; int new_depth; struct Reduction *next; } Reduction; typedef struct Shift { struct SNode *snode; struct Shift *next; } Shift; typedef struct Parser { D_Parser user; /* string to parse */ char *start, *end; struct D_ParserTables *t; /* statistics */ int states, pnodes, scans, shifts, reductions, compares, ambiguities; /* parser state */ PNodeHash pnode_hash; SNodeHash snode_hash; Reduction *reductions_todo; Shift *shifts_todo; D_Scope *top_scope; struct SNode *accept; int last_syntax_error_line; /* memory management */ Reduction *free_reductions; Shift *free_shifts; int live_pnodes; struct PNode *free_pnodes; struct SNode *free_snodes; struct ZNode *free_znodes; Vec(D_Reduction *) error_reductions; ShiftResult *shift_results; int nshift_results; D_Shift *code_shifts; int ncode_shifts; /* comments */ struct Parser *whitespace_parser; /* interface support */ void *pinterface1; #ifdef TRACK_PNODES struct PNode *xall; #endif } Parser; /* Parse Node - the 'symbol' and the constructed parse subtrees. */ typedef struct PNode { uint hash; AssocKind assoc; int priority; AssocKind op_assoc; int op_priority; D_Reduction *reduction; D_Shift *shift; #ifndef USE_GC uint32 refcount; #endif VecPNode children; uint height; /* max tree height */ uint8 evaluated; uint8 error_recovery; struct PNode *all_next; struct PNode *bucket_next; struct PNode *ambiguities; struct PNode *latest; /* latest version of this PNode */ char *ws_before; char *ws_after; D_Scope *initial_scope; void *initial_globals; D_ParseNode parse_node; /* public fields */ #ifdef TRACK_PNODES struct PNode *xnext; struct PNode *xprev; #endif } PNode; /* State Node - the 'state'. */ typedef struct SNode { D_State *state; D_Scope *initial_scope; void *initial_globals; d_loc_t loc; uint depth; /* max stack depth (less loops) */ PNode *last_pn; VecZNode zns; #ifndef USE_GC uint32 refcount; #endif struct SNode *bucket_next; struct SNode *all_next; } SNode; /* (Z)Symbol Node - holds one of the symbols associated with a state. */ typedef struct ZNode { PNode *pn; VecSNode sns; } ZNode; #define znode_next(_z) (*(ZNode**)&((_z)->pn)) D_ParseNode * ambiguity_count_fn(D_Parser *pp, int n, D_ParseNode **v); #endif mcrl2-201210.1/3rd-party/dparser/write_tables.c000775 001751 001751 00000165317 12042421220 022251 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2006 John Plevyak, All Rights Reserved */ #include "d.h" #include "dparse_tables.h" void myfprintf(FILE *f, const char *format, ...) { va_list ap; va_start(ap, format); if(!f) d_warn("trying to write code to binary file"); else vfprintf(f, format, ap); va_end(ap); } #define fprintf myfprintf typedef struct OffsetEntry { char *name; int len; int offset; } OffsetEntry; typedef Vec(OffsetEntry*) OffsetEntrySet; typedef Vec(char*) CharPtrVec; typedef struct Buf { char *start; char *cur; int len; } Buf; typedef struct File { int binary; FILE *fp; unsigned char *cur_str; unsigned char **str; unsigned int *str_len; Buf tables; Buf strings; OffsetEntrySet entries; CharPtrVec relocations; CharPtrVec str_relocations; int first_member; int array_length; int n_elems; int elem_size; int d_parser_tables_loc; } File; OffsetEntry null_entry = {"NULL", sizeof("NULL")-1, -1}; OffsetEntry spec_code_entry = {"#spec_code", sizeof("#spec_code")-1, -2}; OffsetEntry final_code_entry = {"#final_code", sizeof("#final_code")-1, -3}; uint32 offset_hash_fn(OffsetEntry *entry, struct hash_fns_t* fn) { fn = fn; return strhashl(entry->name, entry->len); } int offset_cmp_fn(OffsetEntry *a, OffsetEntry *b, struct hash_fns_t* fn) { fn = fn; return strcmp(a->name, b->name); } hash_fns_t offset_fns = { (hash_fn_t)offset_hash_fn, (cmp_fn_t)offset_cmp_fn, {0, 0} }; static void write_chk(const void* ptr, size_t size, size_t nmemb, File *file) { if (file->fp) { if (fwrite(ptr, size, nmemb, file->fp) != nmemb) d_fail("error writing binary file\n"); } else { memcpy(file->cur_str, ptr, size * nmemb); file->cur_str += size * nmemb; } } static void save_binary_tables(File *file) { int i; BinaryTablesHead tables; unsigned int len; tables.n_relocs = file->relocations.n; tables.n_strings = file->str_relocations.n; tables.d_parser_tables_loc = file->d_parser_tables_loc; tables.tables_size = file->tables.cur - file->tables.start; tables.strings_size = file->strings.cur - file->strings.start; len = sizeof(BinaryTablesHead) + tables.tables_size + tables.strings_size + (file->relocations.n * sizeof(void*)) + (file->str_relocations.n * sizeof(void*)); if (file->str) { file->cur_str = *file->str = (unsigned char*)MALLOC(len); *file->str_len = len; } write_chk(&tables, sizeof(BinaryTablesHead), 1, file); write_chk(file->tables.start, sizeof(char), tables.tables_size, file); write_chk(file->strings.start, sizeof(char), tables.strings_size, file); for (i=0; i < file->relocations.n; i++) write_chk(&file->relocations.v[i], sizeof(void*), 1, file); for (i=0; i < file->str_relocations.n; i++) write_chk(&file->str_relocations.v[i], sizeof(void*), 1, file); } static void free_tables(File *f) { int i; if (f->tables.start) FREE(f->tables.start); if (f->strings.start) FREE(f->strings.start); vec_free(&f->str_relocations); vec_free(&f->relocations); for (i=0; ientries.n; i++) { if (f->entries.v[i]) { FREE(f->entries.v[i]->name); FREE(f->entries.v[i]); f->entries.v[i] = 0; } } vec_free(&f->entries); } static void init_buf(Buf *buf, int initial_size) { buf->len = initial_size; buf->start = MALLOC(buf->len); memset(buf->start, 0, buf->len); buf->cur = buf->start; } static void file_init(File *file, int binary, FILE* fp, unsigned char **str, unsigned int *str_len) { memset(file, 0, sizeof(File)); file->binary = binary; file->fp = fp; file->str = str; file->str_len = str_len; if (binary) { init_buf(&file->tables, 1024); init_buf(&file->strings, 1024); } vec_clear(&file->relocations); vec_clear(&file->entries); vec_clear(&file->str_relocations); } static void make_room_in_buf(Buf *buf, size_t size) { while (buf->cur + size > buf->start + buf->len) { int cur = buf->cur - buf->start; buf->len = buf->len*2 + 1; buf->start = REALLOC(buf->start, buf->len); buf->cur = buf->start + cur; memset(buf->cur, 0, buf->len - (buf->cur - buf->start)); } } static void new_offset(File *fp, char *name) { OffsetEntry *entry = MALLOC(sizeof(OffsetEntry)); memset(entry, 0, sizeof(OffsetEntry)); entry->name = name; entry->offset = fp->tables.cur - fp->tables.start; entry->len = strlen(name); set_add_fn(&fp->entries, entry, &offset_fns); } static uintptr_t make_string(File *fp, const char *name) { intptr_t size = strlen(name)+1; Buf *buf = &fp->strings; char *dest; make_room_in_buf(buf, size); dest = buf->cur; strcpy(dest, name); buf->cur += size; return dest - buf->start; } static OffsetEntry * search_for_offset(File *fp, char *name) { uint32 tt = strhashl(name, strlen(name)); OffsetEntrySet *v = &fp->entries; int j, n = v->n; uint i; if (n) { uint h = tt % n; for (i = h, j = 0; i < v->n && j < SET_MAX_SEQUENTIAL; i = ((i + 1) % n), j++) { if (!v->v[i]) { assert(0); return 0; } else { if (!strcmp(v->v[i]->name, name)) return v->v[i]; } } } assert(0); return 0; } static OffsetEntry * get_offset(File *fp, char* name, ...) { int n; char buf[256]; va_list ap; va_start(ap, name); n = vsnprintf(buf, sizeof(buf), name, ap); va_end(ap); assert(n < 256 && n >= 0); return search_for_offset(fp, buf); } static char* make_name(char* fmt, ...) { int n; char *h_buf, buf[256]; va_list ap; va_start(ap, fmt); n = vsnprintf(buf, sizeof(buf), fmt, ap); va_end(ap); assert(n < 256 && n >= 0); h_buf = MALLOC(n+1); strcpy(h_buf, buf); return h_buf; } static void print_no_comma(File *fp, char *str) { if (!fp->binary) { fprintf(fp->fp, "%s", str); fp->first_member = 1; } } static void print(File *fp, char *str) { if (!fp->binary) { fprintf(fp->fp, "%s", str); } } /* struct: start_struct repeat: add_struct_X_member end_struct array of primitives: start_array repeat: add_array_member or add_array_ptr_member end_array array of structs: start_array repeat: start_struct_in_array repeat: add_struct_X_member end_struct_in_array end_array */ #define start_struct(file, type, name, whitespace) start_struct_fn(file, sizeof(type), #type, name, whitespace) #define start_array(file, type, name, length_str, length_data, whitespace) \ start_array_fn(file, sizeof(type), "", #type, name, length_str, length_data, whitespace) #define add_struct_member(file, struct_type, format, data, member_name) do { \ if ((file)->binary) { \ ((struct_type*)((file)->tables.cur))->member_name = data; \ } else { \ handle_comma(file); \ fprintf((file)->fp, #format, data); \ }} while(0) #define add_struct_const_member(file, struct_type, string, value, member_name) do { \ if ((file)->binary) { \ ((struct_type*)((file)->tables.cur))->member_name = value; \ } else { \ handle_comma(file); \ fprintf((file)->fp, string); \ }} while(0) #define add_struct_str_member(file, struct_type, string, member_name) \ add_struct_str_member_fn(file, (char**)&((struct_type*)(file)->tables.cur)->member_name, string) #define add_struct_ptr_member(file, struct_type, ampersand, entry, member_name) \ add_struct_ptr_member_fn(file, (void**)&((struct_type*)(file)->tables.cur)->member_name, entry, ampersand "%s") #define add_array_member(file, type, format, data, last) do {\ if ((file)->binary) {\ add_array_member_internal(file);\ *((type*)((file)->tables.cur)) = data;\ (file)->tables.cur += (file)->elem_size;\ } else {\ fprintf((file)->fp, #format "%s", data, last ? "" : ",");\ }} while(0) #define add_array_ptr_member(file, type, ampersand, entry, last) \ add_array_ptr_member_fn(file, entry, ampersand "%s%s", last) #define end_struct(file, type, whitespace) end_struct_fn(file, sizeof(type), whitespace) static void add_array_member_internal(File *fp) { fp->n_elems++; make_room_in_buf(&fp->tables, fp->elem_size); } static void handle_comma(File *file) { if (!file->first_member) fprintf(file->fp, ", "); file->first_member = 0; } static void start_array_internal(File *fp, int length, int size) { fp->array_length = length; fp->n_elems = 0; fp->elem_size = size; } static void start_struct_fn(File *fp, int size, char *type_str, char *name, char *whitespace) { new_offset(fp, name); fp->first_member = 1; if (fp->binary) { make_room_in_buf(&fp->tables, size); } else { fprintf(fp->fp, "%s %s = {%s", type_str, name, whitespace); } } static void start_struct_in_array(File *fp) { fp->first_member = 1; if (fp->binary) { add_array_member_internal(fp); } else { fprintf(fp->fp, "{"); } } static void start_array_fn(File *fp, int type_size, char *type_prefix, char *type_str, char *name, char *length_str, int length_data, char *whitespace) { new_offset(fp, name); if (fp->binary) { start_array_internal(fp, length_data, type_size); } else { if (length_data == 0) fprintf(fp->fp, "%s%s %s[] = {%s", type_prefix, type_str, name, whitespace); else if(strlen(length_str) == 0) fprintf(fp->fp, "%s%s %s[%d] = {%s", type_prefix, type_str, name, length_data, whitespace); else fprintf(fp->fp, "%s%s %s[%s] = {%s", type_prefix, type_str, name, length_str, whitespace); } } static void add_struct_str_member_fn(File *fp, char **dest, const char *str) { if (fp->binary) { *dest = (char*)make_string(fp, str); vec_add(&fp->str_relocations, (void*)((char*)dest - fp->tables.start)); } else { if (!fp->first_member) fprintf(fp->fp, ", "); fprintf(fp->fp, "\"%s\"", str); } fp->first_member = 0; } static void add_struct_ptr_member_fn(File *fp, void **dest, OffsetEntry *oe, char *format) { if (fp->binary) { *dest = (void*)(uintptr_t)oe->offset; vec_add(&fp->relocations, (void*)((char*)dest - fp->tables.start)); } else { if (*format == '&' && strcmp(oe->name, "NULL") == 0) format++; if (!fp->first_member) fprintf(fp->fp, ", "); fprintf(fp->fp, format, oe->name); } fp->first_member = 0; } static void add_array_ptr_member_fn(File *fp, OffsetEntry *oe, char *format, int last) { if (fp->binary) { add_array_member_internal(fp); *(void**)fp->tables.cur = (void*)(intptr_t)oe->offset; vec_add(&fp->relocations, (void*)(fp->tables.cur - fp->tables.start)); fp->tables.cur += fp->elem_size; } else { if (*format == '&' && strcmp(oe->name, "NULL") == 0) format++; fprintf(fp->fp, format, oe->name, last ? "" : ","); } } typedef void (*CopyFuncType)(void*,int); static void add_array_member_fn(File *file, CopyFuncType copy, char *format, unsigned int data, int last) { if (file->binary) { add_array_member_internal(file); copy((void*)(file->tables.cur), data); file->tables.cur += file->elem_size; } else { fprintf((file)->fp, format, data); if(!last) fprintf(file->fp, ", "); } } static void end_struct_fn(File *fp, int size, char *whitespace) { if (fp->binary) { fp->tables.cur += size; } else { fprintf(fp->fp, "};%s", whitespace); } } static void end_struct_in_array(File *fp, char *last) { if (fp->binary) { fp->tables.cur += fp->elem_size; } else { fprintf(fp->fp,"}%s", last); } } static void end_array(File *fp, char *whitespace) { if (fp->binary) { if (fp->array_length != 0) { int remaining = (fp->array_length - fp->n_elems)*fp->elem_size; if (remaining) { make_room_in_buf(&fp->tables, remaining); memset(fp->tables.cur, 0, remaining); fp->tables.cur += remaining; } } } else { fprintf(fp->fp, "};%s", whitespace); } } typedef struct ScannerBlock { int state_index; int scanner_index; int block_index; ScanState **chars; ScanStateTransition **transitions; } ScannerBlock; typedef Vec(ScannerBlock*) VecScannerBlock; typedef Vec(State *) VecState; static int scanner_size(State *s) { if (s->scanner.states.n < 255 && s->scanner.transitions.n < 255) return 1; if (s->scanner.states.n < 32384 && s->scanner.transitions.n < 32384) return 2; return 4; } #define copy_func(name, type) static void name(void *dest, int data) { (*(type*)(dest)) = (data); } copy_func(unsigned_char_copy, unsigned char) copy_func(unsigned_short_copy, unsigned short) copy_func(unsigned_int_copy, unsigned int) static CopyFuncType get_copy_func(int i) { switch (i) { case 1: return unsigned_char_copy; case 2: return unsigned_short_copy; case 4: return unsigned_int_copy; default: d_fail("bad case"); return 0; } } static char * make_type(int i) { switch (i) { case 1: return "unsigned char"; case 2: return "unsigned short"; case 4: return "unsigned int"; default: d_fail("bad case"); return ""; } } static char * scanner_type(State *s) { return make_type(scanner_size(s)); } static char * make_u_type(int i) { switch (i) { case 1: return "uint8"; case 2: return "uint16"; case 4: return "uint32"; default: d_fail("bad case"); return ""; } } static char * scanner_u_type(State *s) { return make_u_type(scanner_size(s)); } static uint32 scanner_block_hash_fn(ScannerBlock *b, hash_fns_t *fns) { uint32 hash = 0; intptr_t i, block_size = (intptr_t)fns->data[0]; ScanState **sb = b->chars; for (i = 0; i < block_size; i++) { hash *= 17; hash += sb[i] ? sb[i]->index + 2 : 1; } return hash; } static int scanner_block_cmp_fn(ScannerBlock *a, ScannerBlock *b, hash_fns_t *fns) { intptr_t i, block_size = (intptr_t)fns->data[0]; ScanState **sa = a->chars; ScanState **sb = b->chars; for (i = 0; i < block_size; i++) { if (sa[i] == sb[i]) continue; if (!sa[i] || !sb[i]) return 1; if (sa[i]->index != sb[i]->index) return 1; } return 0; } hash_fns_t scanner_block_fns = { (hash_fn_t)scanner_block_hash_fn, (cmp_fn_t)scanner_block_cmp_fn, {0, 0} }; static uint32 trans_scanner_block_hash_fn(ScannerBlock *b, hash_fns_t *fns) { uint32 hash = 0; intptr_t i, block_size = (intptr_t)fns->data[0]; ScanStateTransition **sb = b->transitions; for (i = 0; i < block_size; i++) { hash *= 3; hash += sb[i] ? sb[i]->index + 1 : 0; } return hash; } static int trans_scanner_block_cmp_fn(ScannerBlock *a, ScannerBlock *b, hash_fns_t *fns) { intptr_t i, block_size = (intptr_t)fns->data[0]; ScanStateTransition **sa = a->transitions; ScanStateTransition **sb = b->transitions; for (i = 0; i < block_size; i++) { if (sa[i] == sb[i]) continue; if (!sa[i] || !sb[i]) return 1; if (sa[i]->index != sb[i]->index) return 1; } return 0; } hash_fns_t trans_scanner_block_fns = { (hash_fn_t)trans_scanner_block_hash_fn, (cmp_fn_t)trans_scanner_block_cmp_fn, {0, 0} }; static uint32 shift_hash_fn(Action *sa, hash_fns_t *fns) { return sa->term->index + (sa->kind == ACTION_SHIFT_TRAILING ? 1000000 : 0); } static int shift_cmp_fn(Action *sa, Action *sb, hash_fns_t *fns) { return (sa->term->index != sb->term->index) || (sa->kind != sb->kind); } hash_fns_t shift_fns = { (hash_fn_t)shift_hash_fn, (cmp_fn_t)shift_cmp_fn, {0, 0} }; static void write_scanner_data(File *fp, Grammar *g, char *tag) { State *s; ScannerBlock *vsblock, *xv, *yv; VecScannerBlock scanner_block_hash[4], *pscanner_block_hash; VecScannerBlock trans_scanner_block_hash[4], *ptrans_scanner_block_hash; VecAction shift_hash; int nvsblocks, ivsblock, i, j, k, x, xx; VecScanState *ss; char speculative_code[256]; Term *t; /* shift_actions */ for (i = 0; i < g->terminals.n; i++) { int action_index = -1; t = g->terminals.v[i]; if (t->regex_production && t->regex_production->rules.v[0]->speculative_code.code) { assert(!fp->binary); sprintf(speculative_code, "d_speculative_reduction_code_%d_%d_%s", t->regex_production->index, t->regex_production->rules.v[0]->index, tag); } else { strcpy(speculative_code, "NULL"); } if (t->regex_production) { action_index = t->regex_production->rules.v[0]->action_index; } start_struct(fp, D_Shift, make_name("d_shift_%d_%s", i, tag), ""); add_struct_member(fp, D_Shift, %d, g->terminals.v[i]->index + g->productions.n, symbol); add_struct_member(fp, D_Shift, %d, g->terminals.v[i]->scan_kind, shift_kind); add_struct_member(fp, D_Shift, %d, g->terminals.v[i]->op_assoc, op_assoc); add_struct_member(fp, D_Shift, %d, g->terminals.v[i]->op_priority, op_priority); add_struct_member(fp, D_Shift, %d, g->terminals.v[i]->term_priority, term_priority); if (fp->binary) { add_struct_member(fp, D_Shift, %d, action_index, action_index); add_struct_ptr_member(fp, D_Shift, "", &spec_code_entry, speculative_code); } else { add_struct_member(fp, D_Shift, %d, 0, action_index); fprintf(fp->fp, ", %s", speculative_code); } end_struct(fp, D_Shift, "\n"); g->write_line++; if (g->terminals.v[i]->trailing_context) { start_struct(fp, D_Shift, make_name("d_tshift_%d_%s", i, tag), ""); add_struct_member(fp, D_Shift, %d, g->terminals.v[i]->index + g->productions.n, symbol); add_struct_member(fp, D_Shift, %d, D_SCAN_TRAILING, shift_kind); add_struct_member(fp, D_Shift, %d, g->terminals.v[i]->op_assoc, op_assoc); add_struct_member(fp, D_Shift, %d, g->terminals.v[i]->op_priority, op_priority); add_struct_member(fp, D_Shift, %d, g->terminals.v[i]->term_priority, term_priority); if (fp->binary) { add_struct_member(fp, D_Shift, %d, action_index, action_index); add_struct_ptr_member(fp, D_Shift, "", &spec_code_entry, speculative_code); } else { add_struct_member(fp, D_Shift, %d, 0, action_index); fprintf(fp->fp, ", %s", speculative_code); } end_struct(fp, D_Shift, "\n"); g->write_line++; } } print(fp, "\n"); g->write_line++; /* scanners */ nvsblocks = 0; for (i = 0; i < g->states.n; i++) nvsblocks += g->states.v[i]->scanner.states.n * g->scanner_blocks; vsblock = MALLOC((nvsblocks ? nvsblocks : 1) * sizeof(ScannerBlock)); for (i = 0; i < 4; i++) { vec_clear(&scanner_block_hash[i]); vec_clear(&trans_scanner_block_hash[i]); } scanner_block_fns.data[0] = (void*)(uintptr_t)g->scanner_block_size; scanner_block_fns.data[1] = (void*)g; trans_scanner_block_fns.data[0] = (void*)(uintptr_t)g->scanner_block_size; trans_scanner_block_fns.data[1] = (void*)g; /* shift */ vec_clear(&shift_hash); ivsblock = 0; for (i = 0; i < g->states.n; i++) { s = g->states.v[i]; if (s->same_shifts) continue; ss = &s->scanner.states; /* build accepts differences */ for (j = 0; j < s->scanner.transitions.n; j++) { VecAction *va = &s->scanner.transitions.v[j]->accepts_diff; start_array(fp, D_Shift *, make_name("d_accepts_diff_%d_%d_%s", i, j, tag), "", 0, ""); for (k = 0; k < va->n; k++) { if (va->v[k]->kind != ACTION_SHIFT_TRAILING) add_array_ptr_member(fp, D_Shift*, "&", get_offset(fp, "d_shift_%d_%s", va->v[k]->term->index, tag), 0); else add_array_ptr_member(fp, D_Shift*, "&", get_offset(fp, "d_tshift_%d_%s", va->v[k]->term->index, tag), 0); } add_array_member(fp, D_Shift*, %d, 0, 1); end_array(fp, "\n"); g->write_line += 2; } if (s->scanner.transitions.n) { start_array(fp, D_Shift **, make_name("d_accepts_diff_%d_%s", i, tag), "", 0, "\n"); for (j = 0; j < s->scanner.transitions.n; j++) { add_array_ptr_member(fp, D_Shift **, "", get_offset(fp, "d_accepts_diff_%d_%d_%s", i, j, tag), j == s->scanner.transitions.n - 1); print(fp, "\n"); if (j != s->scanner.transitions.n - 1) g->write_line++; } end_array(fp, "\n\n"); g->write_line += 3; } /* build scanner_block_hash */ pscanner_block_hash = &scanner_block_hash[scanner_size(s)-1]; ptrans_scanner_block_hash = &trans_scanner_block_hash[scanner_size(s)-1]; for (j = 0; j < ss->n; j++) { if (!s->same_shifts) { for (k = 0; k < g->scanner_blocks; k++) { vsblock[ivsblock].state_index = s->index; vsblock[ivsblock].scanner_index = j; vsblock[ivsblock].block_index = k; vsblock[ivsblock].chars = (void*)&ss->v[j]->chars[k * g->scanner_block_size]; vsblock[ivsblock].transitions = (void*)&ss->v[j]->transition[k * g->scanner_block_size]; xv = &vsblock[ivsblock]; ivsblock++; assert(ivsblock <= nvsblocks); /* output state scanner blocks */ yv = set_add_fn(pscanner_block_hash, xv, &scanner_block_fns); if (xv == yv) { int size = scanner_size(s); start_array_fn(fp, size, "", make_type(size), make_name("d_scanner_%d_%d_%d_%s", i, j, k, tag), "SCANNER_BLOCK_SIZE", SCANNER_BLOCK_SIZE, "\n"); for (x = 0; x < g->scanner_block_size; x++) { xx = x + k * g->scanner_block_size; add_array_member_fn(fp, get_copy_func(size), "%d", ss->v[j]->chars[xx] ? ss->v[j]->chars[xx]->index + 1 : 0, x == g->scanner_block_size); if (x % 16 == 15) { print(fp, "\n"); /*fprintf(fp, "\n");*/ g->write_line++; } } end_array(fp, "\n\n"); g->write_line += 3; } if (s->scan_kind != D_SCAN_LONGEST || s->trailing_context) { /* output accept_diff scanner blocks */ yv = set_add_fn(ptrans_scanner_block_hash, xv, &trans_scanner_block_fns); if (xv == yv) { int size = scanner_size(s); start_array_fn(fp, size, "", make_type(size), make_name("d_accepts_diff_%d_%d_%d_%s", i, j, k, tag), "SCANNER_BLOCK_SIZE", SCANNER_BLOCK_SIZE, "\n"); for (x = 0; x < g->scanner_block_size; x++) { xx = x + k * g->scanner_block_size; add_array_member_fn(fp, get_copy_func(size), "%d", ss->v[j]->transition[xx]->index, x == g->scanner_block_size); if (x % 16 == 15) { print(fp, "\n"); g->write_line++; } } end_array(fp, "\n\n"); g->write_line += 3; } } } /* output shifts */ if (ss->v[j]->accepts.n) { char tmp[256]; sprintf(tmp, "d_shift_%d_%d_%s", i, j, tag); for (k = 0; k < ss->v[j]->accepts.n; k++) { Action *a = ss->v[j]->accepts.v[k], *aa; if (ss->v[j]->accepts.n == 1) { if (a->temp_string) continue; a->temp_string = dup_str(tmp, 0); aa = set_add_fn(&shift_hash, a, &shift_fns); if (aa != a) continue; } /* output shifts */ if (!k) start_array(fp, D_Shift *, make_name(tmp), "", 0, ""); if (a->kind != ACTION_SHIFT_TRAILING) { add_array_ptr_member(fp, D_Shift *, "&", get_offset(fp, "d_shift_%d_%s", a->term->index, tag), 0); if (k == ss->v[j]->accepts.n - 1) { add_array_ptr_member(fp, D_Shift *, "&", &null_entry, 1); end_array(fp, "\n\n"); } } else { add_array_ptr_member(fp, D_Shift *, "&", get_offset(fp, "d_tshift_%d_%s", a->term->index, tag), 0); if (k == ss->v[j]->accepts.n - 1) { add_array_ptr_member(fp, D_Shift *, "&", &null_entry, 1); end_array(fp, "\n\n"); } } if (k == ss->v[j]->accepts.n - 1) g->write_line += 2; } } } } } for (i = 0; i < g->states.n; i++) { s = g->states.v[i]; ss = &s->scanner.states; ivsblock = 0; if (ss->n && !s->same_shifts) { /* output scanner state transition tables */ /* assume SB_uint8, 16, and 32 have same member offsets */ assert(sizeof(SB_uint8) == sizeof(SB_uint16) && sizeof(SB_uint16) == sizeof(SB_uint32)); start_array_fn(fp, sizeof(SB_uint8), "SB_", scanner_u_type(s), make_name("d_scanner_%d_%s", i, tag), "", ss->n, "\n"); g->write_line += 1; pscanner_block_hash = &scanner_block_hash[scanner_size(s)-1]; for (j = 0; j < ss->n; j++) { Action *a; start_struct_in_array(fp); if (ss->v[j]->accepts.n) { a = ss->v[j]->accepts.v[0]; if (ss->v[j]->accepts.n == 1) { a = set_add_fn(&shift_hash, a, &shift_fns); add_struct_ptr_member(fp, SB_uint8, "", get_offset(fp, "%s", a->temp_string), shift); } else add_struct_ptr_member(fp, SB_uint8, "", get_offset(fp, "d_shift_%d_%d_%s", i, j, tag), shift); } else add_struct_ptr_member(fp, SB_uint8, "", &null_entry, shift); print_no_comma(fp, ", {"); for (k = 0; k < g->scanner_blocks; k++) { ScannerBlock vs; vs.state_index = s->index; vs.scanner_index = j; vs.block_index = k; vs.chars = (void*)&ss->v[j]->chars[k * g->scanner_block_size]; vs.transitions = (void*)&ss->v[j]->transition[k * g->scanner_block_size]; xv = &vs; yv = set_add_fn(pscanner_block_hash, xv, &scanner_block_fns); assert(yv != xv); add_struct_ptr_member(fp, SB_uint8, "", get_offset(fp, "d_scanner_%d_%d_%d_%s", yv->state_index, yv->scanner_index, yv->block_index, tag), scanner_block[k]); if (k != g->scanner_blocks-1) { if ((k % 2) == 1) { print(fp, "\n "); g->write_line += 1; } } } print(fp, "}"); end_struct_in_array(fp, j != ss->n-1 ? ",\n" : "\n"); g->write_line += 1; } end_array(fp, "\n\n"); g->write_line += 2; if (s->scan_kind != D_SCAN_LONGEST || s->trailing_context) { /* output scanner accepts diffs tables */ start_array_fn(fp, sizeof(SB_trans_uint8), "SB_trans_", scanner_u_type(s), make_name("d_transition_%d_%s", i, tag), "", ss->n, "\n"); g->write_line += 1; ptrans_scanner_block_hash = &trans_scanner_block_hash[scanner_size(s)-1]; for (j = 0; j < ss->n; j++) { start_struct_in_array(fp); print(fp, "{"); for (k = 0; k < g->scanner_blocks; k++) { ScannerBlock vs; vs.state_index = s->index; vs.scanner_index = j; vs.block_index = k; vs.chars = (void*)&ss->v[j]->chars[k * g->scanner_block_size]; vs.transitions = (void*)&ss->v[j]->transition[k * g->scanner_block_size]; xv = &vs; yv = set_add_fn(ptrans_scanner_block_hash, xv, &trans_scanner_block_fns); assert(yv != xv); add_struct_ptr_member(fp, SB_trans_uint8, "", get_offset(fp, "d_accepts_diff_%d_%d_%d_%s", yv->state_index, yv->scanner_index, yv->block_index, tag), scanner_block[k]); if (k != g->scanner_blocks-1) { if ((k % 2) == 1) { print(fp, "\n "); g->write_line += 1; } } } print(fp, "}"); end_struct_in_array(fp, j != ss->n-1 ? ",\n" : "\n"); g->write_line += 1; } end_array(fp, "\n\n"); g->write_line += 2; } } } for (i = 0; i < 4; i++) { vec_free(&scanner_block_hash[i]); vec_free(&trans_scanner_block_hash[i]); } vec_free(&shift_hash); FREE(vsblock); } #define reduction_index(_r) \ ((_r)->same_reduction ? (_r)->same_reduction->index : (_r)->index) static void write_goto_data(File *fp, Grammar *g, char *tag) { Vec(intptr_t) vgoto; State *s; uint8 *goto_valid = NULL; int i, j, x, again, nvalid_bytes, sym, lowest_sym; nvalid_bytes = ((g->productions.n + g->terminals.n) + 7) / 8; goto_valid = MALLOC(nvalid_bytes); vec_clear(&vgoto); for (i = 0; i < g->states.n; i++) { s = g->states.v[i]; if (s->gotos.n) { /* check for goto on token */ for (j = 0; j < s->gotos.n; j++) if (s->gotos.v[j]->elem->kind == ELEM_TERM && s->gotos.v[j]->elem->e.term->kind == TERM_TOKEN) s->goto_on_token = 1; /* find lowest goto, set valid bits */ memset(goto_valid, 0, nvalid_bytes); lowest_sym = elem_symbol(g, s->gotos.v[0]->elem); SET_BIT(goto_valid, lowest_sym); for (j = 1; j < s->gotos.n; j++) { sym = elem_symbol(g, s->gotos.v[j]->elem); SET_BIT(goto_valid, sym); if (sym < lowest_sym) lowest_sym = sym; } /* insert into vgoto */ again = 1; while (again) { again = 0; for (j = 0; j < s->gotos.n; j++) { x = elem_symbol(g, s->gotos.v[j]->elem); x -= lowest_sym; while (vgoto.n <= x) { int qq = 0; vec_add(&vgoto, 0); for (qq = 0; qq < vgoto.n; qq++) if (vgoto.v[qq] == 239847234) printf("wow...\n"); } if (vgoto.v[x]) { again = 1; /* undo the damage */ for (--j;j >= 0;j--) { x = elem_symbol(g, s->gotos.v[j]->elem); x -= lowest_sym; vgoto.v[x] = 0; } lowest_sym--; break; } else vgoto.v[x] = s->gotos.v[j]->state->index + 1; } } s->goto_table_offset = lowest_sym; /* valid bits */ start_array(fp, unsigned char, make_name("d_goto_valid_%d_%s", i, tag), "", 0, ""); print(fp, "\n"); g->write_line += 1; for (j = 0; j < nvalid_bytes; j++) add_array_member(fp, unsigned char, 0x%x, goto_valid[j], j == nvalid_bytes - 1); end_array(fp, "\n"); g->write_line += 1; } else s->goto_table_offset = -INT_MAX; /* reduce_actions */ if (s->reduce_actions.n) { start_array(fp, D_Reduction *, make_name("d_reductions_%d_%s", i, tag), "", 0, ""); for (j = 0; j < s->reduce_actions.n; j++) add_array_ptr_member(fp, D_Reduction *, "&", get_offset(fp, "d_reduction_%d_%s", reduction_index(s->reduce_actions.v[j]->rule), tag), j == s->reduce_actions.n - 1); end_array(fp, "\n"); g->write_line += 1; } /* modified_reduce_actions */ if (s->right_epsilon_hints.n) { start_array(fp, D_RightEpsilonHint, make_name("d_right_epsilon_hints_%d_%s", i, tag), "", 0, ""); for (j = 0; j < s->right_epsilon_hints.n; j++) { start_struct_in_array(fp); add_struct_member(fp, D_RightEpsilonHint, %d, s->right_epsilon_hints.v[j]->depth, depth); add_struct_member(fp, D_RightEpsilonHint, %d, s->right_epsilon_hints.v[j]->state->index, preceeding_state); add_struct_ptr_member(fp, D_RightEpsilonHint, "&", get_offset(fp, "d_reduction_%d_%s", reduction_index(s->right_epsilon_hints.v[j]->rule), tag), reduction); end_struct_in_array(fp, ((j == s->right_epsilon_hints.n - 1) ? "" : ",")); } end_array(fp, "\n"); g->write_line += 1; } } /* gotos */ if (vgoto.n) { start_array(fp, unsigned short, make_name("d_gotos_%s", tag), "", vgoto.n, "\n"); g->write_line += 1; for (j = 0; j < vgoto.n; j++) { if (vgoto.v[j] < 0 || vgoto.v[j] > 65535) d_fail("goto table overflow"); add_array_member(fp, unsigned short, %d, vgoto.v[j], j == vgoto.n - 1); if (j % 16 == 15) { print(fp, "\n"); g->write_line += 1; } } end_array(fp, "\n\n"); g->write_line += 2; } else { start_array(fp, unsigned short, make_name("d_gotos_%s", tag), "", 1, ""); add_array_member(fp, unsigned short, %d, 0, 1); end_array(fp, "\n"); g->write_line += 1; } vec_free(&vgoto); FREE(goto_valid); } static void write_scanner_code(File *file, Grammar *g, char *tag) { int i, j, l; Action *a; State *s; FILE *fp = file->fp; for (i = 0; i < g->states.n; i++) { s = g->states.v[i]; for (j = 0; j < s->shift_actions.n; j++) { a = s->shift_actions.v[j]; if (a->kind == ACTION_SHIFT && a->term->kind == TERM_CODE) { if (!s->scanner_code) { s->scanner_code = 1; new_offset(file, make_name("d_scan_code_%d_%s", i, tag)); fprintf(fp, "int d_scan_code_%d_%s(d_loc_t *loc," "unsigned short *symbol, int *term_priority," "unsigned char *op_assoc, int *op_priority) {\n" " int res;\n", i, tag); g->write_line += 1; } fprintf(fp, " if ((res = "); l = strlen(a->term->string); if (a->term->string[l - 1] == ')') { fwrite(a->term->string, l - 1, 1, fp); fprintf(fp, ", "); } else fprintf(fp, "%s(", a->term->string); fprintf(fp, "loc, op_assoc, op_priority))) {\n" " *symbol = %d;\n" " *term_priority = %d;\n" " return res;\n" " }\n", a->term->index + g->productions.n, a->term->term_priority); g->write_line += 1; } } if (s->scanner_code) { fprintf(fp, " return 0;\n}\n\n"); g->write_line += 3; } } } static int find_symbol(Grammar *g, char *s, char *e, int kind) { while (*s && isspace_(*s)) s++; if (e > s) { if (kind == D_SYMBOL_NTERM) { Production *p; if ((p = lookup_production(g, s, e-s))) return p->index; } else if (kind == D_SYMBOL_STRING) { int i; int found = -1; for (i = 0; i < g->terminals.n;i++) if (g->terminals.v[i]->kind == TERM_STRING && ((g->terminals.v[i]->term_name && strlen(g->terminals.v[i]->term_name) == e-s && !strncmp(s, g->terminals.v[i]->term_name, e-s)) || (!g->terminals.v[i]->term_name && g->terminals.v[i]->string_len == (e-s) && !strncmp(s, g->terminals.v[i]->string, e-s)))) { if (found > 0) { d_fail("attempt to find symbol for non-unique string '%s'\n", g->terminals.v[i]->string); } else found = i; } if (found > 0) return found + g->productions.n; } } return -1; } static void write_code(FILE *fp, Grammar *g, Rule *r, char *code, char *fname, int line, char *pathname) { char *c; int in_string = 0; if (!fp) { d_warn("trying to write code to binary file"); return; } if (g->write_line_directives) { fprintf(fp, "#line %d \"%s\"\n", line, pathname); g->write_line++; } fprintf(fp, "%s{ ", fname); c = code; while (*c) { if (*c != '\\') { if (c[1] == '\'' || c[1] == '"') { if (in_string == c[1]) in_string = 0; else if (!in_string) in_string = c[1]; } } if (!in_string && *c == '/') { // pass through c++ style comments if (c[1] == '/') { while (*c && *c != '\n') { fputc(*c, fp); c++; } } else if (c[1] == '*') { while (*c && *c != '*' && c[1] != '\\') { fputc(*c, fp); c++; } if (*c) { fputc(*c, fp); c++; fputc(*c, fp); c++; } } } if (*c == '\n') g->write_line++; if (!in_string && *c == '$') { c++; if (*c == '#') { c++; if (isdigit_(*c)) { int n = atoi(c); fprintf(fp, "(d_get_number_of_children((D_PN(_children[%d], _offset))))", n); if (n > r->elems.n-1) d_fail("$nXXXX greater than number of children at line %d", line); while (isdigit_(*c)) c++; } else fprintf(fp, "(_n_children)"); } else if (*c == 'g') { fprintf(fp, "(D_PN(_ps, _offset)->globals)"); c++; } else if (*c == 'n') { ++c; if (isdigit_(*c)) { int n = atoi(c); fprintf(fp, "(*(D_PN(_children[%d], _offset)))", n); if (n > r->elems.n-1) d_fail("$nXXXX greater than number of children at line %d", line); while (isdigit_(*c)) c++; } else fprintf(fp, "(*(D_PN(_ps, _offset)))"); } else if (*c == '$') { fprintf(fp, "(D_PN(_ps, _offset)->user)"); c++; } else if (isdigit_(*c)) { int n = atoi(c); fprintf(fp, "(D_PN(_children[%d], _offset)->user)", n); while (isdigit_(*c)) c++; } else if (*c == '{') { char *e = ++c, *a; while (*e && *e != '}' && !isspace_(*e)) e++; a = e; if (isspace_(*a)) a++; while (*a && *a != '}') a++; if (!*a) d_fail("unterminated ${...} at line %d", line); if (STREQ(c, e-c, "child")) { char xx[2][4096], *x, *y; int i = 0; *xx[0] = 0; *xx[1] = 0; while (*e != '}') { char *ss = e, *n; x = xx[i]; y = xx[!i]; while (*e && *e != '}' && *e != ',') e++; if (!*e || ss == e) d_fail("bad ${...} at line %d", line); n = dup_str(ss, e); if (!*y) sprintf(x, "(D_PN(_children[%s], _offset))", n); else sprintf(x, "d_get_child(%s, %s)", y, n); if (*e == ',') e++; if (isspace_(*e)) e++; i = !i; } if (!xx[!i]) d_fail("empty ${child } at line %d", line); fprintf(fp, "%s", xx[!i]); } else if (STREQ(c, e-c, "reject")) { fprintf(fp, " return -1 "); } else if (STREQ(c, e-c, "free_below")) { fprintf(fp, " free_D_ParseTreeBelow(_parser, (D_PN(_ps, _offset)))"); } else if (STREQ(c, e-c, "scope")) { fprintf(fp, "(D_PN(_ps, _offset)->scope)"); } else if (STREQ(c, e-c, "parser")) { fprintf(fp, "_parser"); } else if (STREQ(c, e-c, "nterm")) { fprintf(fp, "%d", find_symbol(g, e, a, D_SYMBOL_NTERM)); } else if (STREQ(c, e-c, "string")) { fprintf(fp, "%d", find_symbol(g, e, a, D_SYMBOL_STRING)); } else if (STREQ(c, e-c, "pass")) { D_Pass *p = find_pass(g, e, a); if (!p) d_fail("unknown pass '%s' line %d", dup_str(e, a), line); fprintf(fp, "%d", p->index); } else d_fail("bad $ escape in code line %u\n", line); c = a + 1; } else d_fail("bad $ escape in code line %u\n", line); } else { fputc(*c, fp); c++; } } fprintf(fp, " return 0;"); fprintf(fp, "}\n\n"); g->write_line += 2; if (g->write_line_directives) { fprintf(fp, "#line %d \"%s\"\n", g->write_line, g->write_pathname); g->write_line++; } } static void write_global_code(FILE *fp, Grammar *g, char *tag) { int i; char *c; for (i = 0; i < g->ncode; i++) { if (g->write_line_directives) { fprintf(fp, "#line %d \"%s\"\n", g->code[i].line, g->pathname); g->write_line++; } c = g->code[i].code; while (*c) { if (*c == '\n') g->write_line++; if (*c == '$') { c++; if (*c == '{') { char *e = ++c, *a; while (*e && *e != '}' && !isspace_(*e)) ++e; a = e; if (isspace_(*a)) ++a; while (*a && *a != '}') a++; if (STREQ(c, e-c, "nterm")) { fprintf(fp, "%d", find_symbol(g, e, a, D_SYMBOL_NTERM)); } else if (STREQ(c, e-c, "string")) { fprintf(fp, "%d", find_symbol(g, e, a, D_SYMBOL_STRING)); } else if (STREQ(c, e-c, "pass")) { D_Pass *p = find_pass(g, e, a); if (!p) d_fail("unknown pass '%s' line %d", dup_str(e, a), g->code[i].line + i); fprintf(fp, "%d", p->index); } else d_fail("bad $ escape in code line %u\n", g->code[i].line + i); c = a + 1; } else d_fail("bad $ escape in code line %u\n", g->code[i].line + i); } else { fputc(*c, fp); c++; } } fprintf(fp, "\n"); g->write_line += 1; } if (g->write_line_directives) { fprintf(fp, "#line %d \"%s\"\n", g->write_line, g->write_pathname); g->write_line++; } } static char * reduction_args = "(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser)"; static void write_reductions(File *file, Grammar *g, char *tag) { int i, j, k, l, pmax; Production *p, *pdefault; Rule *r, *rdefault = NULL; char final_code[256], speculative_code[256], pass_code[256]; FILE *fp = file->fp; pdefault = lookup_production(g, "_", 1); if (pdefault) { rdefault = pdefault->rules.v[0]; fprintf(fp, "int d_speculative_reduction_code_%d_%d_%s%s;\n", rdefault->prod->index, rdefault->index, tag, reduction_args); g->write_line += 1; fprintf(fp, "int d_final_reduction_code_%d_%d_%s%s;\n", rdefault->prod->index, rdefault->index, tag, reduction_args); g->write_line += 1; fprintf(fp, "extern D_ReductionCode d_pass_code_%d_%d_%s[];\n", rdefault->prod->index, rdefault->index, tag); g->write_line += 1; for (i = 0; i < rdefault->pass_code.n; i++) { fprintf(fp, "int d_pass_code_%d_%d_%d_%s%s;\n", i, rdefault->prod->index, rdefault->index, tag, reduction_args); g->write_line += 1; } } for (i = 0; i < g->productions.n; i++) { p = g->productions.v[i]; for (j = p->rules.n - 1; j >= 0; j--) { r = p->rules.v[j]; for (k = 0; k < j; k++) if (r->elems.n == p->rules.v[k]->elems.n && r->speculative_code.code == p->rules.v[k]->speculative_code.code && r->final_code.code == p->rules.v[k]->final_code.code && r->op_priority == p->rules.v[k]->op_priority && r->op_assoc == p->rules.v[k]->op_assoc && r->rule_priority == p->rules.v[k]->rule_priority && r->rule_assoc == p->rules.v[k]->rule_assoc && r->action_index == p->rules.v[k]->action_index) { if (r->pass_code.n != p->rules.v[k]->pass_code.n) continue; for (l = 0; l < r->pass_code.n; l++) { if (!r->pass_code.v[l] && !p->rules.v[k]->pass_code.v[l]) continue; if (!r->pass_code.v[l] || !p->rules.v[k]->pass_code.v[l]) goto Lcontinue; if (r->pass_code.v[l]->code != p->rules.v[k]->pass_code.v[l]->code) goto Lcontinue; } r->same_reduction = p->rules.v[k]; break; Lcontinue:; } } for (j = 0; j < p->rules.n; j++) { r = p->rules.v[j]; if (r->same_reduction) continue; if (r->speculative_code.code) { char fname[256]; sprintf(fname, "int d_speculative_reduction_code_%d_%d_%s%s ", r->prod->index, r->index, tag, reduction_args); write_code(fp, g, r, r->speculative_code.code, fname, r->speculative_code.line, g->pathname); } if (r->final_code.code) { char fname[256]; sprintf(fname, "int d_final_reduction_code_%d_%d_%s%s ", r->prod->index, r->index, tag, reduction_args); write_code(fp, g, r, r->final_code.code, fname, r->final_code.line, g->pathname); } for (k = 0; k < r->pass_code.n; k++) { if (r->pass_code.v[k]) { char fname[256]; sprintf(fname, "int d_pass_code_%d_%d_%d_%s%s ", k, r->prod->index, r->index, tag, reduction_args); write_code(fp, g, r, r->pass_code.v[k]->code, fname, r->pass_code.v[k]->line, g->pathname); } } if (r->speculative_code.code) sprintf(speculative_code, "d_speculative_reduction_code_%d_%d_%s", r->prod->index, r->index, tag); else if (rdefault && rdefault->speculative_code.code) sprintf(speculative_code, "d_speculative_reduction_code_%d_%d_%s", rdefault->prod->index, rdefault->index, tag); else strcpy(speculative_code, "NULL"); if (r->final_code.code) sprintf(final_code, "d_final_reduction_code_%d_%d_%s", r->prod->index, r->index, tag); else if (rdefault && rdefault->final_code.code) sprintf(final_code, "d_final_reduction_code_%d_%d_%s", rdefault->prod->index, rdefault->index, tag); else strcpy(final_code, "NULL"); pmax = r->pass_code.n; if (r->pass_code.n || (rdefault && rdefault->pass_code.n)) { if (rdefault && rdefault->pass_code.n > pmax) pmax = rdefault->pass_code.n; if (!r->pass_code.n) sprintf(pass_code, "d_pass_code_%d_%d_%s", rdefault->prod->index, rdefault->index, tag); else { sprintf(pass_code, "d_pass_code_%d_%d_%s", r->prod->index, r->index, tag); fprintf(fp, "D_ReductionCode %s[] = {", pass_code); for (k = 0; k < pmax; k++) { if (r->pass_code.n > k && r->pass_code.v[k]) fprintf(fp, "d_pass_code_%d_%d_%d_%s%s", k, r->prod->index, r->index, tag, k < pmax-1 ? ", " : ""); else if (rdefault && rdefault->pass_code.n > k && rdefault->pass_code.v[k]) fprintf(fp, "d_pass_code_%d_%d_%d_%s%s", k, rdefault->prod->index, rdefault->index, tag, k < pmax-1 ? ", " : ""); else fprintf(fp, "NULL%s", k < pmax-1 ? ", " : ""); } fprintf(fp, "};\n\n"); g->write_line += 2; } } else strcpy(pass_code, "NULL"); start_struct(file, D_Reduction, make_name("d_reduction_%d_%s", r->index, tag), ""); add_struct_member(file, D_Reduction, %d, r->elems.n, nelements); add_struct_member(file, D_Reduction, %d, r->prod->index, symbol); if (file->binary) { if (!r->prod->internal && r->action_index >= 0) { add_struct_ptr_member(file, D_Reduction, "", &spec_code_entry, speculative_code); add_struct_ptr_member(file, D_Reduction, "", &final_code_entry, final_code); } else { add_struct_ptr_member(file, D_Reduction, "", &null_entry, speculative_code); add_struct_ptr_member(file, D_Reduction, "", &null_entry, final_code); } } else { fprintf(fp, ", %s", speculative_code); fprintf(fp, ", %s", final_code); } add_struct_member(file, D_Reduction, %d, r->op_assoc, op_assoc); add_struct_member(file, D_Reduction, %d, r->rule_assoc, rule_assoc); add_struct_member(file, D_Reduction, %d, r->op_priority, op_priority); add_struct_member(file, D_Reduction, %d, r->rule_priority, rule_priority); add_struct_member(file, D_Reduction, %d, r->prod->internal ? -1 : r->action_index, action_index); add_struct_member(file, D_Reduction, %d, pmax, npass_code); if (file->binary) { add_struct_ptr_member(file, D_Reduction, "", &null_entry, pass_code); } else { fprintf(fp, ", %s", pass_code); } end_struct(file, D_Reduction, "\n"); g->write_line += 1; } } } static uint32 er_hint_hash_fn(State *a, hash_fns_t *fns) { VecHint *sa = &a->error_recovery_hints; uint32 hash = 0, i; Term *ta; for (i = 0; i < sa->n; i++) { ta = sa->v[i]->rule->elems.v[sa->v[i]->rule->elems.n - 1]->e.term; hash += (sa->v[i]->depth + 1) * 13; hash += strhashl(ta->string, ta->string_len); if (sa->v[i]->rule) hash += sa->v[i]->rule->prod->index * 10007; } return hash; } static int er_hint_cmp_fn(State *a, State *b, hash_fns_t *fns) { int i; VecHint *sa = &a->error_recovery_hints, *sb = &b->error_recovery_hints; Term *ta, *tb; if (sa->n != sb->n) return 1; for (i = 0; i < sa->n; i++) { ta = sa->v[i]->rule->elems.v[sa->v[i]->rule->elems.n - 1]->e.term; tb = sb->v[i]->rule->elems.v[sb->v[i]->rule->elems.n - 1]->e.term; if (sa->v[i]->depth != sb->v[i]->depth || strcmp(ta->string, tb->string) || sa->v[i]->rule->prod->index != sb->v[i]->rule->prod->index) return 1; } return 0; } hash_fns_t er_hint_hash_fns = { (hash_fn_t)er_hint_hash_fn, (cmp_fn_t)er_hint_cmp_fn, {0, 0} }; static void write_error_data(File *fp, Grammar *g, VecState *er_hash, char *tag) { int i, j; State *s; Term *t; State *h; char *ss; if (g->states.n) { for (i = 0; i < g->states.n; i++) { s = g->states.v[i]; if (s->error_recovery_hints.n) { h = set_add_fn(er_hash, s, &er_hint_hash_fns); if (h == s) { start_array(fp, D_ErrorRecoveryHint, make_name("d_error_recovery_hints_%d_%s", i, tag), "", 0, ""); print(fp, s->error_recovery_hints.n > 1 ? "\n" : ""); for (j = 0; j < s->error_recovery_hints.n; j++) { t = s->error_recovery_hints.v[j]->rule->elems.v[ s->error_recovery_hints.v[j]->rule->elems.n - 1]->e.term; ss = escape_string(t->string); start_struct_in_array(fp); add_struct_member(fp, D_ErrorRecoveryHint, %d, s->error_recovery_hints.v[j]->depth, depth); add_struct_member(fp, D_ErrorRecoveryHint, %d, s->error_recovery_hints.v[j]->rule->prod->index, symbol); add_struct_str_member(fp, D_ErrorRecoveryHint, ss, string); end_struct_in_array(fp, j == s->error_recovery_hints.n - 1 ? "" : ",\n"); if (j != s->error_recovery_hints.n - 1) g->write_line += 1; FREE(ss); } end_array(fp, "\n"); g->write_line += 1; } } } } } static char *scan_kind_strings[] = {"D_SCAN_ALL", "D_SCAN_LONGEST", "D_SCAN_MIXED", NULL}; static void write_state_data(File *fp, Grammar *g, VecState *er_hash, char *tag) { int i; State *s, *h, *shifts; print(fp, "\n"); start_array(fp, D_State, make_name("d_states_%s", tag), "", 0, ""); if (g->states.n) { print(fp, "\n"); for (i = 0; i < g->states.n; i++) { s = g->states.v[i]; shifts = s->same_shifts ? s->same_shifts : s; start_struct_in_array(fp); if (s->gotos.n) add_struct_ptr_member(fp, D_State, "", get_offset(fp, "d_goto_valid_%d_%s", i, tag), goto_valid); else add_struct_ptr_member(fp, D_State, "", &null_entry, goto_valid); add_struct_member(fp, D_State, %d, s->goto_table_offset, goto_table_offset); print_no_comma(fp, ", {"); if (s->reduce_actions.n) { add_struct_member(fp, D_State, %d, s->reduce_actions.n, reductions.n); add_struct_ptr_member(fp, D_State, "", get_offset(fp, "d_reductions_%d_%s", i, tag), reductions.v); } else { add_struct_member(fp, D_State, %d, 0, reductions.n); add_struct_ptr_member(fp, D_State, "", &null_entry, reductions.v); } print(fp, "}, "); print_no_comma(fp, "{"); if (s->right_epsilon_hints.n) { add_struct_member(fp, D_State, %d, s->right_epsilon_hints.n, right_epsilon_hints.n); add_struct_ptr_member(fp, D_State, "", get_offset(fp, "d_right_epsilon_hints_%d_%s", i, tag), right_epsilon_hints.v); } else { add_struct_member(fp, D_State, %d, 0, right_epsilon_hints.n); add_struct_ptr_member(fp, D_State, "", &null_entry, right_epsilon_hints.v); } print(fp, "}, "); print_no_comma(fp, "{"); if (s->error_recovery_hints.n) { h = set_add_fn(er_hash, s, &er_hint_hash_fns); add_struct_member(fp, D_State, %d, s->error_recovery_hints.n, error_recovery_hints.n); add_struct_ptr_member(fp, D_State, "", get_offset(fp, "d_error_recovery_hints_%d_%s", h->index, tag), error_recovery_hints.v); } else { add_struct_member(fp, D_State, %d, 0, error_recovery_hints.n); add_struct_ptr_member(fp, D_State, "", &null_entry, error_recovery_hints.v); } print(fp, "}"); if (s->shift_actions.n || s->scanner_code || (g->scanner.code && s->goto_on_token)) add_struct_member(fp, D_State, %d, 1, shifts); else add_struct_member(fp, D_State, %d, 0, shifts); if (g->scanner.code) { if (s->goto_on_token) { assert(!fp->binary); fprintf(fp->fp, ", %s", g->scanner.code); } else { add_struct_ptr_member(fp, D_State, "", &null_entry, scanner_code); } } else if (s->scanner_code) add_struct_ptr_member(fp, D_State, "", get_offset(fp, "d_scan_code_%d_%s", i, tag), scanner_code); else add_struct_ptr_member(fp, D_State, "", &null_entry, scanner_code); if (s->scanner.states.n) { print_no_comma(fp, ", (void*)"); add_struct_ptr_member(fp, D_State, "", get_offset(fp, "d_scanner_%d_%s", shifts->index, tag), scanner_table); } else { add_struct_ptr_member(fp, D_State, "", &null_entry, scanner_table); } if (!fp->binary) fprintf(fp->fp, ", sizeof(%s) ", scanner_type(s)); else add_struct_member(fp, D_State, %d, scanner_size(s), scanner_size); add_struct_member(fp, D_State, %d, s->accept ? 1 : 0, accept); add_struct_const_member(fp, D_State, scan_kind_strings[s->scan_kind], s->scan_kind, scan_kind); if ((shifts->scan_kind != D_SCAN_LONGEST || shifts->trailing_context) && shifts->scanner.states.n) { print_no_comma(fp, ", (void*)"); add_struct_ptr_member(fp, D_State, "", get_offset(fp, "d_transition_%d_%s", shifts->index, tag), transition_table); } else { add_struct_ptr_member(fp, D_State, "", &null_entry, transition_table); } if ((shifts->scan_kind != D_SCAN_LONGEST || shifts->trailing_context) && shifts->scanner.states.n) add_struct_ptr_member(fp, D_State, "", get_offset(fp, "d_accepts_diff_%d_%s", shifts->index, tag), accepts_diff); else add_struct_ptr_member(fp, D_State, "", &null_entry, accepts_diff); if (s->reduces_to) add_struct_member(fp, D_State, %d, s->reduces_to->index, reduces_to); else add_struct_member(fp, D_State, %d, -1, reduces_to); end_struct_in_array(fp, (i == g->states.n - 1 ? "\n" : ",\n")); } end_array(fp, "\n\n"); } else { if (!fp->binary) /*BS it doesn't look like this fits a D_State?*/ fprintf(fp->fp, "{{0, {0, NULL}, 0, NULL}};\n\n"); else d_fail("no states\n"); } } static int write_header(Grammar *g, char *base_pathname, char *tag) { char pathname[FILENAME_MAX]; char ver[128]; int i, tokens = 0, states = 0, col; FILE *hfp; for (i = 0; i < g->terminals.n; i++) if (g->terminals.v[i]->kind == TERM_TOKEN) tokens = 1; if (g->states_for_all_nterms) states = 1; else for (i = 0; i < g->productions.n; i++) if (state_for_declaration(g, i)) states = 1; if (g->write_header > 0 || (g->write_header < 0 && (tokens || states))) { strcpy(pathname, base_pathname); strcat(pathname, ".d_parser.h"); hfp = fopen(pathname, "w"); if (!hfp) d_fail("unable to open `%s` for write\n", pathname); d_version(ver); fprintf(hfp, "/*\n Generated by Make DParser Version %s\n", ver); fprintf(hfp, " Available at http://dparser.sf.net\n*/\n\n"); fprintf(hfp, "#ifndef _%s_h\n", tag); fprintf(hfp, "#define _%s_h\n", tag); if (tokens) { if (!g->token_type) { for (i = 0; i < g->terminals.n; i++) if (g->terminals.v[i]->kind == TERM_TOKEN) fprintf(hfp, "#define %s \t%d\n", g->terminals.v[i]->string, g->terminals.v[i]->index + g->productions.n); } else { fprintf(hfp, "enum D_Tokens_%s {\n", tag); col = 0; for (i = 0; i < g->terminals.n; i++) { if (g->terminals.v[i]->kind == TERM_TOKEN) { col += g->terminals.v[i]->string_len + 7; if (col > 70) { printf("\n"); col = 0; } fprintf(hfp, "%s = %d%s", g->terminals.v[i]->string, g->terminals.v[i]->index + g->productions.n, i == g->terminals.n-1 ? "" : ", "); } } fprintf(hfp, "\n};\n"); } } if (states) { for (i = 0; i < g->productions.n; i++) if (!g->productions.v[i]->internal && g->productions.v[i]->elem) fprintf(hfp, "#define D_START_STATE_%s \t%d\n", g->productions.v[i]->name, g->productions.v[i]->state->index); } fprintf(hfp, "#endif\n"); fclose(hfp); return 1; } return 0; } #define is_EBNF(_x) (_x == INTERNAL_CONDITIONAL || _x == INTERNAL_STAR || _x == INTERNAL_PLUS) static char *d_internal[] = {"D_SYMBOL_NTERM", "D_SYMBOL_EBNF", "D_SYMBOL_INTERNAL"}; static int d_internal_values[] = {D_SYMBOL_NTERM, D_SYMBOL_EBNF, D_SYMBOL_INTERNAL}; static char *d_symbol[] = { "D_SYMBOL_STRING", "D_SYMBOL_REGEX", "D_SYMBOL_CODE", "D_SYMBOL_TOKEN" }; static int d_symbol_values[] = { D_SYMBOL_STRING, D_SYMBOL_REGEX, D_SYMBOL_CODE, D_SYMBOL_TOKEN }; static void write_symbol_data(File *fp, Grammar *g, char *tag) { int i; start_array(fp, D_Symbol, make_name("d_symbols_%s", tag), "", 0, "\n"); g->write_line += 1; for (i = 0; i < g->productions.n; i++) { int state = -1, internal_index; if (!g->productions.v[i]->internal && g->productions.v[i]->elem) state = g->productions.v[i]->state->index; start_struct_in_array(fp); internal_index = g->productions.v[i]->internal ? (is_EBNF(g->productions.v[i]->internal) ? 2 : 1) : 0; add_struct_const_member(fp, D_Symbol, d_internal[internal_index], d_internal_values[internal_index], kind); add_struct_str_member(fp, D_Symbol, g->productions.v[i]->name, name); add_struct_member(fp, D_Symbol, %d, g->productions.v[i]->name_len, name_len); add_struct_member(fp, D_Symbol, %d, state, start_symbol); end_struct_in_array(fp, ",\n"); g->write_line += 1; } for (i = 0; i < g->terminals.n; i++) { char *s = escape_string(g->terminals.v[i]->string); /* so it is a string */ char *ss = escape_string(s); /* so it is printable */ char *name = g->terminals.v[i]->term_name ? g->terminals.v[i]->term_name : (fp->binary ? s : ss); int symbol_index = g->terminals.v[i]->kind; start_struct_in_array(fp); add_struct_const_member(fp, D_Symbol, d_symbol[symbol_index], d_symbol_values[symbol_index], kind); add_struct_str_member(fp, D_Symbol, name, name); add_struct_member(fp, D_Symbol, %d, (int) strlen(name), name_len); /*BS strlen doesn't always works here, length can change when quoted string is compiled*/ end_struct_in_array(fp, ",\n"); g->write_line += 1; FREE(s); FREE(ss); } end_array(fp, "\n\n"); g->write_line += 2; } static void write_passes(File *fp, Grammar *g, char *tag) { int i; if (g->passes.n) { start_array(fp, D_Pass, make_name("d_passes_%s", tag), "", 0, ""); g->write_line += 1; for (i = 0; i < g->passes.n; i++) { D_Pass *p = g->passes.v[i]; start_struct_in_array(fp); add_struct_str_member(fp, D_Pass, p->name, name); add_struct_member(fp, D_Pass, %d, p->name_len, name_len); add_struct_member(fp, D_Pass, 0x%X, p->kind, kind); add_struct_member(fp, D_Pass, %d, p->index, index); end_struct_in_array(fp, i < g->passes.n-1 ? ", " : ""); } end_array(fp, "\n\n"); g->write_line += 2; } } void write_parser_tables(Grammar *g, char *tag, File *file) { int whitespace_production = 0; VecState er_hash; Production *p; vec_clear(&er_hash); g->scanner_block_size = 256/g->scanner_blocks; write_reductions(file, g, tag); write_scanner_data(file, g, tag); if (!file->binary) write_scanner_code(file, g, tag); write_goto_data(file, g, tag); write_error_data(file, g, &er_hash, tag); write_state_data(file, g, &er_hash, tag); write_symbol_data(file, g, tag); write_passes(file, g, tag); vec_free(&er_hash); if ((p = lookup_production(g, "whitespace", sizeof("whitespace")-1))) whitespace_production = p->state->index; if (file->binary) { file->d_parser_tables_loc = file->tables.cur - file->tables.start; } start_struct(file, D_ParserTables, make_name("parser_tables_%s", tag), "\n"); add_struct_member(file, D_ParserTables, %d, g->states.n, nstates); add_struct_ptr_member(file, D_ParserTables, "", get_offset(file, "d_states_%s", tag), state); add_struct_ptr_member(file, D_ParserTables, "", get_offset(file, "d_gotos_%s", tag), goto_table); add_struct_member(file, D_ParserTables, %d, whitespace_production, whitespace_state); add_struct_member(file, D_ParserTables, %d, g->productions.n + g->terminals.n, nsymbols); add_struct_ptr_member(file, D_ParserTables, "", get_offset(file, "d_symbols_%s", tag), symbols); if (g->default_white_space) { assert(!file->binary); fprintf(file->fp, ", %s", g->default_white_space); } else add_struct_ptr_member(file, D_ParserTables, "", &null_entry, default_white_space); add_struct_member(file, D_ParserTables, %d, g->passes.n, npasses); if (g->passes.n) add_struct_ptr_member(file, D_ParserTables, "", get_offset(file, "d_passes_%s", tag), passes); else add_struct_ptr_member(file, D_ParserTables, "", &null_entry, passes); if (g->save_parse_tree) add_struct_member(file, D_ParserTables, %d, 1, save_parse_tree); else add_struct_member(file, D_ParserTables, %d, 0, save_parse_tree); end_struct(file, D_ParserTables, "\n"); if (file->binary) { if (!file->str) { file->fp = fopen(g->write_pathname, "wb"); if (!file->fp) d_fail("unable to open `%s` for write\n", g->pathname); } save_binary_tables(file); } free_tables(file); if (file->fp) fclose(file->fp); } void write_parser_tables_internal(Grammar *g, char *base_pathname, char *tag, int binary, FILE *fp, unsigned char **str, unsigned int *str_len) { File file; if (!binary) { fp = fopen(g->write_pathname, "w"); if (!fp) d_fail("unable to open `%s` for write\n", g->write_pathname); } file_init(&file, binary, fp, str, str_len); if (!binary) { char ver[128]; int header = write_header(g, base_pathname, tag); d_version(ver); fprintf(fp, "/*\n Generated by Make DParser Version %s\n", ver); fprintf(fp, " Available at http://dparser.sf.net\n*/\n\n"); g->write_line = 7; write_global_code(fp, g, tag); fprintf(fp, "#include \"dparse.h\"\n"); g->write_line++; if (header) { fprintf(fp, "#include \"%s.d_parser.h\"\n", base_pathname); g->write_line++; } fprintf(fp, "\n"); g->write_line++; } write_parser_tables(g, tag, &file); } int write_c_tables(Grammar *g) { write_parser_tables_internal(g, g->pathname, *g->grammar_ident ? g->grammar_ident : NULL, 0, 0, 0, 0); return 0; } int write_binary_tables(Grammar *g) { write_parser_tables_internal(g, g->pathname, *g->grammar_ident ? g->grammar_ident : NULL, 1, 0, 0, 0); return 0; } int write_binary_tables_to_file(Grammar *g, FILE *fp) { write_parser_tables_internal(g, g->pathname, *g->grammar_ident ? g->grammar_ident : NULL, 1, fp, 0, 0); return 0; } int write_binary_tables_to_string(Grammar *g, unsigned char **str, unsigned int *str_len) { write_parser_tables_internal(g, g->pathname, *g->grammar_ident ? g->grammar_ident : NULL, 1, 0, str, str_len); return 0; } mcrl2-201210.1/3rd-party/dparser/lex.h000775 001751 001751 00000000764 12042421220 020354 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ #ifndef _lex_H_ #define _lex_H_ /* #define LIVE_DIFF_IN_TRANSITIONS */ struct Grammar; typedef struct ScanStateTransition { uint index; VecAction live_diff; VecAction accepts_diff; } ScanStateTransition; typedef struct ScanState { uint index; struct ScanState *chars[256]; VecAction accepts; VecAction live; ScanStateTransition *transition[256]; } ScanState; void build_scanners(struct Grammar *g); #endif mcrl2-201210.1/3rd-party/dparser/d.h000775 001751 001751 00000005060 12042421220 020001 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ #ifndef _d_H_ #define _d_H_ #ifdef MEMWATCH #define MEMWATCH_STDIO 1 #include "../../src/memwatch-2.67/memwatch.h" #define MEM_GROW_MACRO #endif #include #include #include #include #if !defined(__FreeBSD__) || (__FreeBSD_version >= 500000) #include #endif #include #include #if !defined(__MINGW32__) && !defined(_MSC_VER) #include #include #endif #include #include #include #include #include #include #include #include #ifdef LEAK_DETECT #define GC_DEBUG #include "gc.h" #define MALLOC(n) GC_MALLOC(n) #define CALLOC(m,n) GC_MALLOC((m)*(n)) #define FREE(p) GC_FREE(p) #define REALLOC(p,n) GC_REALLOC((p),(n)) #define CHECK_LEAKS() GC_gcollect() #else #ifdef USE_GC #include "gc.h" #define MALLOC GC_MALLOC #define REALLOC GC_REALLOC #define FREE(_x) #define malloc dont_use_malloc_use_MALLOC_instead #define relloc dont_use_realloc_use_REALLOC_instead #define free dont_use_free_use_FREE_instead #else #define MALLOC malloc #define REALLOC realloc #define FREE free #endif #endif // enough already with the signed/unsiged char issues #define isspace_(_c) isspace((unsigned char)(_c)) #define isdigit_(_c) isdigit((unsigned char)(_c)) #define isxdigit_(_c) isxdigit((unsigned char)(_c)) #define isprint_(_c) isprint((unsigned char)(_c)) #define D_VERSION (\ (D_MAJOR_VERSION << 24) + (D_MINOR_VERSION << 16) + \ D_BUILD_VERSION) /* Compilation Options */ #define round2(_x,_n) ((_x + ((_n)-1)) & ~((_n)-1)) #define tohex1(_x) \ ((((_x)&15) > 9) ? (((_x)&15) - 10 + 'A') : (((_x)&15) + '0')) #define tohex2(_x) \ ((((_x)>>4) > 9) ? (((_x)>>4) - 10 + 'A') : (((_x)>>4) + '0')) #define numberof(_x) ((sizeof(_x))/(sizeof((_x)[0]))) typedef char int8; typedef unsigned char uint8; typedef int int32; typedef unsigned int uint32; typedef long long int64; typedef unsigned long long uint64; typedef short int16; typedef unsigned short uint16; #if defined(__MINGW32__) || defined(_MSC_VER) /* already part of most systems */ typedef unsigned long ulong; typedef uint32 uint; #endif #include "dparse.h" #include "arg.h" #include "util.h" #include "gram.h" #include "lr.h" #include "lex.h" #include "scan.h" #include "parse.h" #include "write_tables.h" #include "read_binary.h" #ifdef D_DEBUG #define DBG(_x) if (d_debug_level>1) { _x; } #else #define DBG(_x) #endif void d_version(char *); #define USE_SCANNER 1 #endif mcrl2-201210.1/3rd-party/dparser/grammar.g.c000775 001751 001751 00001244721 12042421220 021436 0ustar00jenkinsjenkins000000 000000 /* Generated by Make DParser Version 1.19.27 Available at http://dparser.sf.net */ #line 4 "grammar.g" #include "gramgram.h" #include "d.h" #line 12 "grammar.g.d_parser.c" #include "dparse.h" D_Reduction d_reduction_0_dparser_gram = {1, 0, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_1_dparser_gram = {1, 1, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_2_dparser_gram = {2, 2, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_3_dparser_gram = {0, 2, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_4_dparser_gram = {1, 3, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; #line 13 "grammar.g" int d_final_reduction_code_4_7_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { char *grammar_pathname = dup_str((*(D_PN(_children[1], _offset))).start_loc.s+1, (*(D_PN(_children[1], _offset))).end-1); if (parse_grammar((D_PN(_ps, _offset)->globals), grammar_pathname, 0) < 0) d_fail("unable to parse grammar '%s'", grammar_pathname); FREE(grammar_pathname); return 0;} #line 28 "grammar.g.d_parser.c" D_Reduction d_reduction_7_dparser_gram = {2, 4, NULL, d_final_reduction_code_4_7_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 22 "grammar.g" int d_final_reduction_code_5_8_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { add_global_code((D_PN(_ps, _offset)->globals), (*(D_PN(_children[0], _offset))).start_loc.s+2, (*(D_PN(_children[2], _offset))).end-2, (*(D_PN(_children[0], _offset))).start_loc.line); return 0;} #line 33 "grammar.g.d_parser.c" D_Reduction d_reduction_8_dparser_gram = {3, 5, NULL, d_final_reduction_code_5_8_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 23 "grammar.g" int d_final_reduction_code_5_9_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { add_global_code((D_PN(_ps, _offset)->globals), (*(D_PN(_children[0], _offset))).start_loc.s+1, (*(D_PN(_children[0], _offset))).end-1, (*(D_PN(_children[0], _offset))).start_loc.line); return 0;} #line 38 "grammar.g.d_parser.c" D_Reduction d_reduction_9_dparser_gram = {1, 5, NULL, d_final_reduction_code_5_9_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 24 "grammar.g" int d_final_reduction_code_5_10_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->scanner.code = dup_str((*(D_PN(_children[1], _offset))).start_loc.s, (*(D_PN(_children[1], _offset))).end); (D_PN(_ps, _offset)->globals)->scanner.line = (*(D_PN(_children[0], _offset))).start_loc.line; return 0;} #line 46 "grammar.g.d_parser.c" D_Reduction d_reduction_10_dparser_gram = {3, 5, NULL, d_final_reduction_code_5_10_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 28 "grammar.g" int d_final_reduction_code_5_11_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { if (!d_get_number_of_children(&(*(D_PN(_children[2], _offset))))) add_declaration((D_PN(_ps, _offset)->globals), (*(D_PN(_children[2], _offset))).start_loc.s, (*(D_PN(_children[2], _offset))).end, (D_PN(_children[1], _offset)->user).kind, (*(D_PN(_children[2], _offset))).start_loc.line); else { int i, n = d_get_number_of_children(&(*(D_PN(_children[2], _offset)))); for (i = 0; i < n; i++) { D_ParseNode *pn = d_get_child(&(*(D_PN(_children[2], _offset))), i); add_declaration((D_PN(_ps, _offset)->globals), pn->start_loc.s, pn->end, (D_PN(_children[1], _offset)->user).kind, pn->start_loc.line); } } return 0;} #line 61 "grammar.g.d_parser.c" D_Reduction d_reduction_11_dparser_gram = {4, 5, NULL, d_final_reduction_code_5_11_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_12_dparser_gram = {3, 5, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; #line 40 "grammar.g" int d_final_reduction_code_5_13_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { add_pass((D_PN(_ps, _offset)->globals), (*(D_PN(_children[1], _offset))).start_loc.s, (*(D_PN(_children[1], _offset))).end, (D_PN(_children[2], _offset)->user).kind, (*(D_PN(_children[1], _offset))).start_loc.line); return 0;} #line 69 "grammar.g.d_parser.c" D_Reduction d_reduction_13_dparser_gram = {4, 5, NULL, d_final_reduction_code_5_13_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_14_dparser_gram = {2, 6, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_15_dparser_gram = {1, 6, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_16_dparser_gram = {2, 7, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_17_dparser_gram = {0, 7, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_18_dparser_gram = {2, 8, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_19_dparser_gram = {1, 8, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_20_dparser_gram = {2, 9, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_21_dparser_gram = {0, 9, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_22_dparser_gram = {0, 10, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; #line 47 "grammar.g" int d_final_reduction_code_10_23_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->user).kind = (D_PN(_children[0], _offset)->user).kind | (D_PN(_children[1], _offset)->user).kind; return 0;} #line 83 "grammar.g.d_parser.c" D_Reduction d_reduction_23_dparser_gram = {2, 10, NULL, d_final_reduction_code_10_23_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 51 "grammar.g" int d_final_reduction_code_11_24_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->user).kind |= D_PASS_PRE_ORDER; return 0;} #line 88 "grammar.g.d_parser.c" D_Reduction d_reduction_24_dparser_gram = {1, 11, NULL, d_final_reduction_code_11_24_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 52 "grammar.g" int d_final_reduction_code_11_25_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->user).kind |= D_PASS_POST_ORDER; return 0;} #line 93 "grammar.g.d_parser.c" D_Reduction d_reduction_25_dparser_gram = {1, 11, NULL, d_final_reduction_code_11_25_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 53 "grammar.g" int d_final_reduction_code_11_26_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->user).kind |= D_PASS_MANUAL; return 0;} #line 98 "grammar.g.d_parser.c" D_Reduction d_reduction_26_dparser_gram = {1, 11, NULL, d_final_reduction_code_11_26_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 54 "grammar.g" int d_final_reduction_code_11_27_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->user).kind |= D_PASS_FOR_ALL; return 0;} #line 103 "grammar.g.d_parser.c" D_Reduction d_reduction_27_dparser_gram = {1, 11, NULL, d_final_reduction_code_11_27_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 55 "grammar.g" int d_final_reduction_code_11_28_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->user).kind |= D_PASS_FOR_UNDEFINED; return 0;} #line 108 "grammar.g.d_parser.c" D_Reduction d_reduction_28_dparser_gram = {1, 11, NULL, d_final_reduction_code_11_28_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 59 "grammar.g" int d_final_reduction_code_12_29_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->user).kind = DECLARE_TOKENIZE; return 0;} #line 113 "grammar.g.d_parser.c" D_Reduction d_reduction_29_dparser_gram = {1, 12, NULL, d_final_reduction_code_12_29_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 60 "grammar.g" int d_final_reduction_code_12_30_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->user).kind = DECLARE_LONGEST_MATCH; return 0;} #line 118 "grammar.g.d_parser.c" D_Reduction d_reduction_30_dparser_gram = {1, 12, NULL, d_final_reduction_code_12_30_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 61 "grammar.g" int d_final_reduction_code_12_31_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->user).kind = DECLARE_WHITESPACE; return 0;} #line 123 "grammar.g.d_parser.c" D_Reduction d_reduction_31_dparser_gram = {1, 12, NULL, d_final_reduction_code_12_31_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 62 "grammar.g" int d_final_reduction_code_12_32_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->user).kind = DECLARE_ALL_MATCHES; return 0;} #line 128 "grammar.g.d_parser.c" D_Reduction d_reduction_32_dparser_gram = {1, 12, NULL, d_final_reduction_code_12_32_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 63 "grammar.g" int d_final_reduction_code_12_33_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->user).kind = DECLARE_SET_OP_PRIORITY; return 0;} #line 133 "grammar.g.d_parser.c" D_Reduction d_reduction_33_dparser_gram = {1, 12, NULL, d_final_reduction_code_12_33_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 64 "grammar.g" int d_final_reduction_code_12_34_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->user).kind = DECLARE_STATES_FOR_ALL_NTERMS; return 0;} #line 138 "grammar.g.d_parser.c" D_Reduction d_reduction_34_dparser_gram = {1, 12, NULL, d_final_reduction_code_12_34_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 65 "grammar.g" int d_final_reduction_code_12_35_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->user).kind = DECLARE_STATE_FOR; return 0;} #line 143 "grammar.g.d_parser.c" D_Reduction d_reduction_35_dparser_gram = {1, 12, NULL, d_final_reduction_code_12_35_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 66 "grammar.g" int d_final_reduction_code_12_36_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->user).kind = DECLARE_SAVE_PARSE_TREE; return 0;} #line 148 "grammar.g.d_parser.c" D_Reduction d_reduction_36_dparser_gram = {1, 12, NULL, d_final_reduction_code_12_36_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 69 "grammar.g" int d_final_reduction_code_13_37_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { new_token((D_PN(_ps, _offset)->globals), (*(D_PN(_children[0], _offset))).start_loc.s, (*(D_PN(_children[0], _offset))).end); return 0;} #line 153 "grammar.g.d_parser.c" D_Reduction d_reduction_37_dparser_gram = {1, 13, NULL, d_final_reduction_code_13_37_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_38_dparser_gram = {4, 14, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_40_dparser_gram = {1, 14, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; #line 75 "grammar.g" int d_final_reduction_code_15_41_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->p->regex = 1; return 0;} #line 162 "grammar.g.d_parser.c" D_Reduction d_reduction_41_dparser_gram = {1, 15, NULL, d_final_reduction_code_15_41_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 79 "grammar.g" int d_final_reduction_code_16_42_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->p = new_production((D_PN(_ps, _offset)->globals), dup_str((*(D_PN(_children[0], _offset))).start_loc.s, (*(D_PN(_children[0], _offset))).end)); return 0;} #line 167 "grammar.g.d_parser.c" D_Reduction d_reduction_42_dparser_gram = {1, 16, NULL, d_final_reduction_code_16_42_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_43_dparser_gram = {1, 17, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_45_dparser_gram = {2, 18, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_46_dparser_gram = {2, 19, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_47_dparser_gram = {0, 19, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_48_dparser_gram = {2, 20, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; #line 83 "grammar.g" int d_final_reduction_code_21_49_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { vec_add(&(D_PN(_ps, _offset)->globals)->p->rules, (D_PN(_ps, _offset)->globals)->r); return 0;} #line 179 "grammar.g.d_parser.c" D_Reduction d_reduction_49_dparser_gram = {4, 21, NULL, d_final_reduction_code_21_49_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_50_dparser_gram = {2, 22, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_51_dparser_gram = {0, 22, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_52_dparser_gram = {1, 23, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_53_dparser_gram = {0, 23, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_54_dparser_gram = {3, 24, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_55_dparser_gram = {2, 25, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_56_dparser_gram = {0, 25, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_57_dparser_gram = {2, 26, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_58_dparser_gram = {0, 26, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_59_dparser_gram = {2, 27, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_60_dparser_gram = {2, 28, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_61_dparser_gram = {0, 28, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; #line 87 "grammar.g" int d_final_reduction_code_29_62_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->r = new_rule((D_PN(_ps, _offset)->globals), (D_PN(_ps, _offset)->globals)->p); return 0;} #line 196 "grammar.g.d_parser.c" D_Reduction d_reduction_62_dparser_gram = {0, 29, NULL, d_final_reduction_code_29_62_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 90 "grammar.g" int d_final_reduction_code_30_63_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->e = new_string((D_PN(_ps, _offset)->globals), (*(D_PN(_children[0], _offset))).start_loc.s, (*(D_PN(_children[0], _offset))).end, (D_PN(_ps, _offset)->globals)->r); return 0;} #line 201 "grammar.g.d_parser.c" D_Reduction d_reduction_63_dparser_gram = {1, 30, NULL, d_final_reduction_code_30_63_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 91 "grammar.g" int d_final_reduction_code_30_64_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->e = new_string((D_PN(_ps, _offset)->globals), (*(D_PN(_children[0], _offset))).start_loc.s, (*(D_PN(_children[0], _offset))).end, (D_PN(_ps, _offset)->globals)->r); return 0;} #line 206 "grammar.g.d_parser.c" D_Reduction d_reduction_64_dparser_gram = {1, 30, NULL, d_final_reduction_code_30_64_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 92 "grammar.g" int d_final_reduction_code_30_65_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->e = new_utf8_char((D_PN(_ps, _offset)->globals), (*(D_PN(_children[0], _offset))).start_loc.s, (*(D_PN(_children[0], _offset))).end, (D_PN(_ps, _offset)->globals)->r); return 0;} #line 211 "grammar.g.d_parser.c" D_Reduction d_reduction_65_dparser_gram = {1, 30, NULL, d_final_reduction_code_30_65_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 93 "grammar.g" int d_final_reduction_code_30_66_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->e = new_ident((*(D_PN(_children[0], _offset))).start_loc.s, (*(D_PN(_children[0], _offset))).end, (D_PN(_ps, _offset)->globals)->r); return 0;} #line 216 "grammar.g.d_parser.c" D_Reduction d_reduction_66_dparser_gram = {1, 30, NULL, d_final_reduction_code_30_66_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 94 "grammar.g" int d_final_reduction_code_30_67_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->e = new_code((D_PN(_ps, _offset)->globals), (*(D_PN(_children[1], _offset))).start_loc.s, (*(D_PN(_children[1], _offset))).end, (D_PN(_ps, _offset)->globals)->r); return 0;} #line 221 "grammar.g.d_parser.c" D_Reduction d_reduction_67_dparser_gram = {3, 30, NULL, d_final_reduction_code_30_67_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 95 "grammar.g" int d_final_reduction_code_30_68_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->e = new_elem_nterm((D_PN(_ps, _offset)->globals)->p, (D_PN(_children[1], _offset)->user).r); (D_PN(_ps, _offset)->globals)->p = (D_PN(_children[1], _offset)->user).p; (D_PN(_ps, _offset)->globals)->r = (D_PN(_children[1], _offset)->user).r; vec_add(&(D_PN(_ps, _offset)->globals)->r->elems, (D_PN(_ps, _offset)->globals)->e); return 0;} #line 231 "grammar.g.d_parser.c" D_Reduction d_reduction_68_dparser_gram = {4, 30, NULL, d_final_reduction_code_30_68_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_69_dparser_gram = {2, 31, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_70_dparser_gram = {1, 31, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_71_dparser_gram = {1, 32, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; #line 105 "grammar.g" int d_final_reduction_code_32_72_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { Production *p = new_internal_production((D_PN(_ps, _offset)->globals), NULL); Rule *r = new_rule((D_PN(_ps, _offset)->globals), p); vec_add(&p->rules, r); r->speculative_code.code = dup_str((*(D_PN(_children[0], _offset))).start_loc.s + 1, (*(D_PN(_children[0], _offset))).end - 1); r->speculative_code.line = (*(D_PN(_children[0], _offset))).start_loc.line; (D_PN(_ps, _offset)->globals)->e = new_elem_nterm(p, (D_PN(_ps, _offset)->globals)->r); vec_add(&(D_PN(_ps, _offset)->globals)->r->elems, (D_PN(_ps, _offset)->globals)->e); return 0;} #line 247 "grammar.g.d_parser.c" D_Reduction d_reduction_72_dparser_gram = {1, 32, NULL, d_final_reduction_code_32_72_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 114 "grammar.g" int d_final_reduction_code_32_73_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { Production *p = new_internal_production((D_PN(_ps, _offset)->globals), NULL); Rule *r = new_rule((D_PN(_ps, _offset)->globals), p); vec_add(&p->rules, r); r->final_code.code = dup_str((*(D_PN(_children[0], _offset))).start_loc.s + 1, (*(D_PN(_children[0], _offset))).end - 1); r->final_code.line = (*(D_PN(_children[0], _offset))).start_loc.line; (D_PN(_ps, _offset)->globals)->e = new_elem_nterm(p, (D_PN(_ps, _offset)->globals)->r); vec_add(&(D_PN(_ps, _offset)->globals)->r->elems, (D_PN(_ps, _offset)->globals)->e); return 0;} #line 260 "grammar.g.d_parser.c" D_Reduction d_reduction_73_dparser_gram = {1, 32, NULL, d_final_reduction_code_32_73_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 125 "grammar.g" int d_final_reduction_code_33_74_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->user).p = (D_PN(_ps, _offset)->globals)->p; (D_PN(_ps, _offset)->user).r = (D_PN(_ps, _offset)->globals)->r; (D_PN(_ps, _offset)->globals)->p = new_internal_production((D_PN(_ps, _offset)->globals), (D_PN(_ps, _offset)->globals)->p); (D_PN(_ps, _offset)->globals)->r = 0; return 0;} #line 270 "grammar.g.d_parser.c" D_Reduction d_reduction_74_dparser_gram = {0, 33, NULL, d_final_reduction_code_33_74_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 133 "grammar.g" int d_final_reduction_code_34_75_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { if ((D_PN(_ps, _offset)->globals)->e->kind != ELEM_TERM) d_fail("terminal priority on non-terminal"); (D_PN(_ps, _offset)->globals)->e->e.term->term_priority = strtol((*(D_PN(_children[1], _offset))).start_loc.s, NULL, 0); return 0;} #line 279 "grammar.g.d_parser.c" D_Reduction d_reduction_75_dparser_gram = {2, 34, NULL, d_final_reduction_code_34_75_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 138 "grammar.g" int d_final_reduction_code_34_76_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { if ((D_PN(_ps, _offset)->globals)->e->kind != ELEM_TERM) d_fail("terminal name on non-terminal"); (D_PN(_ps, _offset)->globals)->e->e.term->term_name = dup_str((*(D_PN(_children[1], _offset))).start_loc.s+1, (*(D_PN(_children[1], _offset))).end-1); return 0;} #line 288 "grammar.g.d_parser.c" D_Reduction d_reduction_76_dparser_gram = {2, 34, NULL, d_final_reduction_code_34_76_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 143 "grammar.g" int d_final_reduction_code_34_77_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { if ((D_PN(_ps, _offset)->globals)->e->kind != ELEM_TERM) d_fail("ignore-case (/i) on non-terminal"); (D_PN(_ps, _offset)->globals)->e->e.term->ignore_case = 1; return 0;} #line 297 "grammar.g.d_parser.c" D_Reduction d_reduction_77_dparser_gram = {1, 34, NULL, d_final_reduction_code_34_77_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 148 "grammar.g" int d_final_reduction_code_34_78_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { conditional_EBNF((D_PN(_ps, _offset)->globals)); return 0;} #line 302 "grammar.g.d_parser.c" D_Reduction d_reduction_78_dparser_gram = {1, 34, NULL, d_final_reduction_code_34_78_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 149 "grammar.g" int d_final_reduction_code_34_79_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { star_EBNF((D_PN(_ps, _offset)->globals)); return 0;} #line 307 "grammar.g.d_parser.c" D_Reduction d_reduction_79_dparser_gram = {1, 34, NULL, d_final_reduction_code_34_79_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 150 "grammar.g" int d_final_reduction_code_34_80_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { plus_EBNF((D_PN(_ps, _offset)->globals)); return 0;} #line 312 "grammar.g.d_parser.c" D_Reduction d_reduction_80_dparser_gram = {1, 34, NULL, d_final_reduction_code_34_80_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 151 "grammar.g" int d_final_reduction_code_34_81_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { rep_EBNF((D_PN(_ps, _offset)->globals), strtol((*(D_PN(_children[1], _offset))).start_loc.s, NULL, 0), -1); return 0;} #line 317 "grammar.g.d_parser.c" D_Reduction d_reduction_81_dparser_gram = {2, 34, NULL, d_final_reduction_code_34_81_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 152 "grammar.g" int d_final_reduction_code_34_82_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { rep_EBNF((D_PN(_ps, _offset)->globals), strtol((*(D_PN(_children[1], _offset))).start_loc.s, NULL, 0), strtol((*(D_PN(_children[3], _offset))).start_loc.s, NULL, 0)); return 0;} #line 322 "grammar.g.d_parser.c" D_Reduction d_reduction_82_dparser_gram = {4, 34, NULL, d_final_reduction_code_34_82_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_83_dparser_gram = {1, 35, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_85_dparser_gram = {2, 36, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_86_dparser_gram = {1, 36, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; #line 158 "grammar.g" int d_final_reduction_code_37_87_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->r->op_assoc = ASSOC_UNARY_RIGHT; return 0;} #line 330 "grammar.g.d_parser.c" D_Reduction d_reduction_87_dparser_gram = {1, 37, NULL, d_final_reduction_code_37_87_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 159 "grammar.g" int d_final_reduction_code_37_88_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->r->op_assoc = ASSOC_UNARY_LEFT; return 0;} #line 335 "grammar.g.d_parser.c" D_Reduction d_reduction_88_dparser_gram = {1, 37, NULL, d_final_reduction_code_37_88_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 160 "grammar.g" int d_final_reduction_code_37_89_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->r->op_assoc = ASSOC_BINARY_RIGHT; return 0;} #line 340 "grammar.g.d_parser.c" D_Reduction d_reduction_89_dparser_gram = {1, 37, NULL, d_final_reduction_code_37_89_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 161 "grammar.g" int d_final_reduction_code_37_90_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->r->op_assoc = ASSOC_BINARY_LEFT; return 0;} #line 345 "grammar.g.d_parser.c" D_Reduction d_reduction_90_dparser_gram = {1, 37, NULL, d_final_reduction_code_37_90_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 162 "grammar.g" int d_final_reduction_code_37_91_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->r->rule_assoc = ASSOC_UNARY_RIGHT; return 0;} #line 350 "grammar.g.d_parser.c" D_Reduction d_reduction_91_dparser_gram = {1, 37, NULL, d_final_reduction_code_37_91_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 163 "grammar.g" int d_final_reduction_code_37_92_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->r->rule_assoc = ASSOC_UNARY_LEFT; return 0;} #line 355 "grammar.g.d_parser.c" D_Reduction d_reduction_92_dparser_gram = {1, 37, NULL, d_final_reduction_code_37_92_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 164 "grammar.g" int d_final_reduction_code_37_93_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->r->rule_assoc = ASSOC_BINARY_RIGHT; return 0;} #line 360 "grammar.g.d_parser.c" D_Reduction d_reduction_93_dparser_gram = {1, 37, NULL, d_final_reduction_code_37_93_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 165 "grammar.g" int d_final_reduction_code_37_94_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->r->rule_assoc = ASSOC_BINARY_LEFT; return 0;} #line 365 "grammar.g.d_parser.c" D_Reduction d_reduction_94_dparser_gram = {1, 37, NULL, d_final_reduction_code_37_94_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 166 "grammar.g" int d_final_reduction_code_37_95_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->r->rule_assoc = ASSOC_NARY_RIGHT; return 0;} #line 370 "grammar.g.d_parser.c" D_Reduction d_reduction_95_dparser_gram = {1, 37, NULL, d_final_reduction_code_37_95_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 167 "grammar.g" int d_final_reduction_code_37_96_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->r->rule_assoc = ASSOC_NARY_LEFT; return 0;} #line 375 "grammar.g.d_parser.c" D_Reduction d_reduction_96_dparser_gram = {1, 37, NULL, d_final_reduction_code_37_96_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 170 "grammar.g" int d_final_reduction_code_38_97_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { if ((D_PN(_ps, _offset)->globals)->r->op_assoc) (D_PN(_ps, _offset)->globals)->r->op_priority = strtol((*(D_PN(_children[0], _offset))).start_loc.s, NULL, 0); else (D_PN(_ps, _offset)->globals)->r->rule_priority = strtol((*(D_PN(_children[0], _offset))).start_loc.s, NULL, 0); return 0;} #line 383 "grammar.g.d_parser.c" D_Reduction d_reduction_97_dparser_gram = {1, 38, NULL, d_final_reduction_code_38_97_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 176 "grammar.g" int d_final_reduction_code_39_98_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->r->action_index = (D_PN(_ps, _offset)->globals)->action_index++; return 0;} #line 388 "grammar.g.d_parser.c" D_Reduction d_reduction_98_dparser_gram = {1, 39, NULL, d_final_reduction_code_39_98_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 177 "grammar.g" int d_final_reduction_code_39_99_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->r->action_index = strtol((*(D_PN(_children[1], _offset))).start_loc.s, NULL, 0); return 0;} #line 393 "grammar.g.d_parser.c" D_Reduction d_reduction_99_dparser_gram = {3, 39, NULL, d_final_reduction_code_39_99_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_100_dparser_gram = {3, 40, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_101_dparser_gram = {2, 41, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_102_dparser_gram = {0, 41, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_103_dparser_gram = {1, 42, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_104_dparser_gram = {0, 42, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_105_dparser_gram = {1, 43, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_106_dparser_gram = {0, 43, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; #line 182 "grammar.g" int d_final_reduction_code_44_107_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->r->speculative_code.code = dup_str((*(D_PN(_children[0], _offset))).start_loc.s + 1, (*(D_PN(_children[0], _offset))).end - 1); (D_PN(_ps, _offset)->globals)->r->speculative_code.line = (*(D_PN(_children[0], _offset))).start_loc.line; return 0;} #line 408 "grammar.g.d_parser.c" D_Reduction d_reduction_107_dparser_gram = {1, 44, NULL, d_final_reduction_code_44_107_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 187 "grammar.g" int d_final_reduction_code_45_108_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { (D_PN(_ps, _offset)->globals)->r->final_code.code = dup_str((*(D_PN(_children[0], _offset))).start_loc.s + 1, (*(D_PN(_children[0], _offset))).end - 1); (D_PN(_ps, _offset)->globals)->r->final_code.line = (*(D_PN(_children[0], _offset))).start_loc.line; return 0;} #line 416 "grammar.g.d_parser.c" D_Reduction d_reduction_108_dparser_gram = {1, 45, NULL, d_final_reduction_code_45_108_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; #line 192 "grammar.g" int d_final_reduction_code_46_109_dparser_gram(void *_ps, void **_children, int _n_children, int _offset, D_Parser *_parser) { add_pass_code((D_PN(_ps, _offset)->globals), (D_PN(_ps, _offset)->globals)->r, (*(D_PN(_children[0], _offset))).start_loc.s, (*(D_PN(_children[0], _offset))).end, (*(D_PN(_children[2], _offset))).start_loc.s+1, (*(D_PN(_children[2], _offset))).end-1, (*(D_PN(_children[0], _offset))).start_loc.line, (*(D_PN(_children[2], _offset))).start_loc.line); return 0;} #line 424 "grammar.g.d_parser.c" D_Reduction d_reduction_109_dparser_gram = {3, 46, NULL, d_final_reduction_code_46_109_dparser_gram, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_110_dparser_gram = {3, 47, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_111_dparser_gram = {2, 48, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_112_dparser_gram = {0, 48, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_113_dparser_gram = {3, 49, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_114_dparser_gram = {2, 50, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_115_dparser_gram = {0, 50, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_116_dparser_gram = {3, 51, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_119_dparser_gram = {1, 51, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_124_dparser_gram = {2, 52, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_125_dparser_gram = {0, 52, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_126_dparser_gram = {2, 53, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_127_dparser_gram = {0, 53, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_128_dparser_gram = {2, 54, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_129_dparser_gram = {0, 54, NULL, NULL, 0, 0, 0, 0, -1, 0, NULL}; D_Reduction d_reduction_130_dparser_gram = {1, 55, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_131_dparser_gram = {1, 56, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_132_dparser_gram = {1, 57, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_133_dparser_gram = {1, 58, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_134_dparser_gram = {1, 59, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_135_dparser_gram = {1, 60, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_138_dparser_gram = {1, 61, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_139_dparser_gram = {1, 62, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; D_Reduction d_reduction_140_dparser_gram = {1, 63, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_0_dparser_gram = {64, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_1_dparser_gram = {65, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_2_dparser_gram = {66, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_3_dparser_gram = {67, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_4_dparser_gram = {68, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_5_dparser_gram = {69, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_6_dparser_gram = {70, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_7_dparser_gram = {71, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_8_dparser_gram = {72, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_9_dparser_gram = {73, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_10_dparser_gram = {74, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_11_dparser_gram = {75, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_12_dparser_gram = {76, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_13_dparser_gram = {77, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_14_dparser_gram = {78, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_15_dparser_gram = {79, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_16_dparser_gram = {80, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_17_dparser_gram = {81, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_18_dparser_gram = {82, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_19_dparser_gram = {83, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_20_dparser_gram = {84, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_21_dparser_gram = {85, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_22_dparser_gram = {86, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_23_dparser_gram = {87, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_24_dparser_gram = {88, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_25_dparser_gram = {89, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_26_dparser_gram = {90, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_27_dparser_gram = {91, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_28_dparser_gram = {92, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_29_dparser_gram = {93, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_30_dparser_gram = {94, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_31_dparser_gram = {95, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_32_dparser_gram = {96, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_33_dparser_gram = {97, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_34_dparser_gram = {98, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_35_dparser_gram = {99, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_36_dparser_gram = {100, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_37_dparser_gram = {101, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_38_dparser_gram = {102, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_39_dparser_gram = {103, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_40_dparser_gram = {104, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_41_dparser_gram = {105, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_42_dparser_gram = {106, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_43_dparser_gram = {107, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_44_dparser_gram = {108, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_45_dparser_gram = {109, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_46_dparser_gram = {110, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_47_dparser_gram = {111, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_48_dparser_gram = {112, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_49_dparser_gram = {113, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_50_dparser_gram = {114, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_51_dparser_gram = {115, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_52_dparser_gram = {116, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_53_dparser_gram = {117, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_54_dparser_gram = {118, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_55_dparser_gram = {119, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_56_dparser_gram = {120, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_57_dparser_gram = {121, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_58_dparser_gram = {122, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_59_dparser_gram = {123, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_60_dparser_gram = {124, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_61_dparser_gram = {125, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_62_dparser_gram = {126, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_63_dparser_gram = {127, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_64_dparser_gram = {128, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_65_dparser_gram = {129, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_66_dparser_gram = {130, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_67_dparser_gram = {131, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_68_dparser_gram = {132, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_69_dparser_gram = {133, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_70_dparser_gram = {134, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_71_dparser_gram = {135, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_72_dparser_gram = {136, 0, 0, 0, -1, 0, NULL}; D_Shift d_shift_73_dparser_gram = {137, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_74_dparser_gram = {138, 0, 0, 0, 0, 0, NULL}; D_Shift d_shift_75_dparser_gram = {139, 0, 0, 0, 0, 0, NULL}; D_Shift * d_accepts_diff_2_0_dparser_gram[] = {0}; D_Shift * d_accepts_diff_2_1_dparser_gram[] = {&d_shift_0_dparser_gram,0}; D_Shift * d_accepts_diff_2_2_dparser_gram[] = {&d_shift_29_dparser_gram,0}; D_Shift ** d_accepts_diff_2_dparser_gram[] = { d_accepts_diff_2_0_dparser_gram, d_accepts_diff_2_1_dparser_gram, d_accepts_diff_2_2_dparser_gram }; unsigned char d_scanner_2_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, }; unsigned char d_accepts_diff_2_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_2_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 6, 0, 5, 5, 5, 5, 5, 5, 5, 5, 7, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 8, 0, 0, 0, 0, }; unsigned char d_scanner_2_0_2_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_2_1_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, }; unsigned char d_scanner_2_2_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, }; D_Shift * d_shift_2_3_dparser_gram[] = {&d_shift_25_dparser_gram,NULL}; unsigned char d_scanner_2_4_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_2_4_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 5, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, }; D_Shift * d_shift_2_4_dparser_gram[] = {&d_shift_72_dparser_gram,NULL}; unsigned char d_accepts_diff_2_5_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, }; unsigned char d_accepts_diff_2_5_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 2, 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, 0, 0, 0, 0, 0, }; D_Shift * d_shift_2_5_dparser_gram[] = {&d_shift_29_dparser_gram,NULL}; unsigned char d_scanner_2_6_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 5, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 11, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, }; D_Shift * d_shift_2_7_dparser_gram[] = {&d_shift_58_dparser_gram,NULL}; unsigned char d_scanner_2_8_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_2_9_dparser_gram[] = {&d_shift_1_dparser_gram,NULL}; unsigned char d_scanner_2_10_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 5, 0, 5, 5, 16, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, }; unsigned char d_scanner_2_11_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 17, 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, }; unsigned char d_scanner_2_12_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 18, 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, }; unsigned char d_scanner_2_13_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 19, 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, }; unsigned char d_scanner_2_14_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_2_15_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 5, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 21, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, }; unsigned char d_scanner_2_16_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 22, 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, }; unsigned char d_scanner_2_17_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_2_18_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 24, 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, }; unsigned char d_scanner_2_19_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_2_20_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 5, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 26, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, }; unsigned char d_scanner_2_21_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 27, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_2_22_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_2_23_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_2_24_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 30, 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, }; unsigned char d_scanner_2_25_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 5, 0, 5, 5, 5, 31, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, }; unsigned char d_scanner_2_26_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 32, 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, }; D_Shift * d_shift_2_27_dparser_gram[] = {&d_shift_9_dparser_gram,NULL}; unsigned char d_scanner_2_28_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_2_29_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_2_30_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 5, 0, 5, 5, 5, 5, 35, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, }; unsigned char d_scanner_2_31_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_2_32_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 37, 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, }; D_Shift * d_shift_2_33_dparser_gram[] = {&d_shift_7_dparser_gram,NULL}; unsigned char d_accepts_diff_2_34_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, }; unsigned char d_accepts_diff_2_34_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 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, 0, 0, 0, 0, 1, 0, 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, 0, 0, 0, 0, 0, }; D_Shift * d_shift_2_34_dparser_gram[] = {&d_shift_0_dparser_gram,NULL}; unsigned char d_scanner_2_35_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 38, 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, }; unsigned char d_scanner_2_36_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_2_37_dparser_gram[] = {&d_shift_5_dparser_gram,NULL}; D_Shift * d_shift_2_38_dparser_gram[] = {&d_shift_3_dparser_gram,NULL}; D_Shift * d_accepts_diff_3_0_dparser_gram[] = {0}; D_Shift ** d_accepts_diff_3_dparser_gram[] = { d_accepts_diff_3_0_dparser_gram }; unsigned char d_scanner_3_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 2, 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, }; unsigned char d_scanner_3_1_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, }; unsigned char d_scanner_3_1_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, }; unsigned char d_scanner_3_1_2_dparser_gram[SCANNER_BLOCK_SIZE] = { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, }; D_Shift * d_shift_3_3_dparser_gram[] = {&d_shift_70_dparser_gram,NULL}; unsigned char d_scanner_3_4_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, }; unsigned char d_scanner_3_4_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, }; D_Shift * d_accepts_diff_5_0_dparser_gram[] = {0}; D_Shift * d_accepts_diff_5_1_dparser_gram[] = {&d_shift_68_dparser_gram,0}; D_Shift * d_accepts_diff_5_2_dparser_gram[] = {&d_shift_75_dparser_gram,0}; D_Shift ** d_accepts_diff_5_dparser_gram[] = { d_accepts_diff_5_0_dparser_gram, d_accepts_diff_5_1_dparser_gram, d_accepts_diff_5_2_dparser_gram }; unsigned char d_scanner_5_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 2, 3, 2, 2, 2, 2, 4, 5, 0, 2, 2, 2, 6, 2, 2, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 2, 2, 2, 2, 2, 2, }; unsigned char d_scanner_5_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 2, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 10, 2, 0, 2, 11, 2, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 12, 2, 0, 2, 0, }; D_Shift * d_shift_5_1_dparser_gram[] = {&d_shift_68_dparser_gram,NULL}; unsigned char d_scanner_5_2_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 14, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, }; unsigned char d_scanner_5_2_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 15, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, }; unsigned char d_scanner_5_2_2_dparser_gram[SCANNER_BLOCK_SIZE] = { 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, }; unsigned char d_scanner_5_3_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, }; unsigned char d_scanner_5_3_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 18, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, }; unsigned char d_scanner_5_3_2_dparser_gram[SCANNER_BLOCK_SIZE] = { 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, }; D_Shift * d_shift_5_4_dparser_gram[] = {&d_shift_33_dparser_gram,NULL}; unsigned char d_scanner_5_5_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_5_6_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 19, 19, 19, 19, 19, 19, 19, 19, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_5_6_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 22, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_accepts_diff_5_6_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 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, 2, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_5_6_dparser_gram[] = {&d_shift_75_dparser_gram,NULL}; unsigned char d_scanner_5_7_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_5_7_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_5_7_dparser_gram[] = {&d_shift_73_dparser_gram,NULL}; unsigned char d_scanner_5_8_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_5_8_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 9, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, }; D_Shift * d_shift_5_9_dparser_gram[] = {&d_shift_60_dparser_gram,NULL}; unsigned char d_scanner_5_14_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, }; unsigned char d_scanner_5_14_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, }; D_Shift * d_shift_5_16_dparser_gram[] = {&d_shift_69_dparser_gram,NULL}; unsigned char d_scanner_5_17_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, }; unsigned char d_scanner_5_17_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, }; unsigned char d_scanner_5_18_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_5_20_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_5_20_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 26, 26, 26, 26, 26, 26, 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, 26, 26, 26, 26, 26, 26, 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, }; unsigned char d_scanner_5_25_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 26, 26, 26, 26, 26, 26, 0, 0, 0, 0, 0, 27, 0, 0, 0, 0, 0, 0, 0, 0, 27, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 26, 26, 26, 26, 26, 0, 0, 0, 0, 0, 27, 0, 0, 0, 0, 0, 0, 0, 0, 27, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_5_25_dparser_gram[] = {&d_shift_74_dparser_gram,NULL}; D_Shift * d_accepts_diff_6_0_dparser_gram[] = {0}; D_Shift ** d_accepts_diff_6_dparser_gram[] = { d_accepts_diff_6_0_dparser_gram }; unsigned char d_scanner_6_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 5, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_1_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_2_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_3_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_4_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_5_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_6_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_7_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_8_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_9_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_10_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 18, 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, }; unsigned char d_scanner_6_11_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_12_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_13_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 21, 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, }; unsigned char d_scanner_6_14_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_15_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 23, 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, }; unsigned char d_scanner_6_16_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 24, 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, }; unsigned char d_scanner_6_17_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_18_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 26, 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, }; unsigned char d_scanner_6_19_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_20_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 28, 0, 0, 0, 0, 0, 29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_22_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 31, 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, }; unsigned char d_scanner_6_23_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_24_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 33, 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, }; unsigned char d_scanner_6_26_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 35, 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, }; unsigned char d_scanner_6_27_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 36, 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, }; unsigned char d_scanner_6_28_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_29_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 38, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_30_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_31_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_32_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_33_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_34_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_35_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_36_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 45, 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, }; unsigned char d_scanner_6_37_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_38_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 47, 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, }; unsigned char d_scanner_6_39_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 48, 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, }; unsigned char d_scanner_6_40_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_41_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 50, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_42_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_43_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 52, 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, }; unsigned char d_scanner_6_44_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_45_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 54, 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, }; unsigned char d_scanner_6_46_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_47_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_48_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 57, 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, }; unsigned char d_scanner_6_49_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 58, 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, }; unsigned char d_scanner_6_50_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 59, 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, }; unsigned char d_scanner_6_51_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 60, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_52_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 61, 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, }; unsigned char d_scanner_6_53_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 62, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_54_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_55_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_56_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_6_57_dparser_gram[] = {&d_shift_16_dparser_gram,NULL}; unsigned char d_scanner_6_58_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 66, 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, }; unsigned char d_scanner_6_59_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 67, 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, }; unsigned char d_scanner_6_60_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_61_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 69, 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, }; unsigned char d_scanner_6_62_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 70, 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, }; unsigned char d_scanner_6_63_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 71, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_6_64_dparser_gram[] = {&d_shift_22_dparser_gram,NULL}; unsigned char d_scanner_6_65_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 72, 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, }; unsigned char d_scanner_6_66_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 73, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_67_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 74, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_68_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 75, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_69_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 76, 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, }; unsigned char d_scanner_6_70_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 77, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_6_71_dparser_gram[] = {&d_shift_18_dparser_gram,NULL}; D_Shift * d_shift_6_72_dparser_gram[] = {&d_shift_19_dparser_gram,NULL}; unsigned char d_scanner_6_73_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 78, 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, }; unsigned char d_scanner_6_74_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 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, 0, 0, 0, 0, }; unsigned char d_scanner_6_75_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_76_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 81, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_77_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 82, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_78_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 83, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_79_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_80_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_81_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 86, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_6_82_dparser_gram[] = {&d_shift_17_dparser_gram,NULL}; unsigned char d_scanner_6_83_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 87, 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, }; unsigned char d_scanner_6_84_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 88, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_6_85_dparser_gram[] = {&d_shift_21_dparser_gram,NULL}; unsigned char d_scanner_6_86_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 89, 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, }; unsigned char d_scanner_6_87_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 90, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_6_88_dparser_gram[] = {&d_shift_23_dparser_gram,NULL}; unsigned char d_scanner_6_89_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 91, 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, }; unsigned char d_scanner_6_90_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 92, 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, }; unsigned char d_scanner_6_91_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 93, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_92_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 94, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_93_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_94_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 96, 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, }; unsigned char d_scanner_6_95_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 97, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_96_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_97_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_6_98_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 100, 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, }; D_Shift * d_shift_6_99_dparser_gram[] = {&d_shift_20_dparser_gram,NULL}; D_Shift * d_accepts_diff_7_0_dparser_gram[] = {0}; D_Shift ** d_accepts_diff_7_dparser_gram[] = { d_accepts_diff_7_0_dparser_gram }; unsigned char d_scanner_7_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 2, 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, 0, 0, 0, 0, 0, }; unsigned char d_scanner_7_1_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, }; D_Shift * d_accepts_diff_17_0_dparser_gram[] = {0}; D_Shift * d_accepts_diff_17_1_dparser_gram[] = {&d_shift_24_dparser_gram,0}; D_Shift ** d_accepts_diff_17_dparser_gram[] = { d_accepts_diff_17_0_dparser_gram, d_accepts_diff_17_1_dparser_gram }; unsigned char d_scanner_17_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, }; unsigned char d_scanner_17_1_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, }; unsigned char d_accepts_diff_17_1_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, }; D_Shift * d_shift_17_1_dparser_gram[] = {&d_shift_24_dparser_gram,NULL}; unsigned char d_scanner_17_2_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, }; D_Shift * d_shift_17_3_dparser_gram[] = {&d_shift_28_dparser_gram,NULL}; D_Shift * d_accepts_diff_23_0_dparser_gram[] = {0}; D_Shift * d_accepts_diff_23_1_dparser_gram[] = {&d_shift_75_dparser_gram,0}; D_Shift * d_accepts_diff_23_2_dparser_gram[] = {&d_shift_68_dparser_gram,0}; D_Shift ** d_accepts_diff_23_dparser_gram[] = { d_accepts_diff_23_0_dparser_gram, d_accepts_diff_23_1_dparser_gram, d_accepts_diff_23_2_dparser_gram }; unsigned char d_scanner_23_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 2, 3, 2, 2, 4, 2, 5, 6, 0, 2, 2, 2, 7, 2, 2, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 2, 2, 2, 2, 2, 2, }; unsigned char d_scanner_23_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 2, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 2, 0, 2, 12, 2, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 13, 2, 0, 2, 0, }; unsigned char d_scanner_23_2_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, }; unsigned char d_scanner_23_2_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 16, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, }; unsigned char d_scanner_23_2_2_dparser_gram[SCANNER_BLOCK_SIZE] = { 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, }; unsigned char d_scanner_23_3_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, }; unsigned char d_accepts_diff_23_3_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, }; unsigned char d_scanner_23_4_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 19, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, }; unsigned char d_scanner_23_4_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 20, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, }; unsigned char d_scanner_23_4_2_dparser_gram[SCANNER_BLOCK_SIZE] = { 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, }; unsigned char d_scanner_23_6_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_23_7_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 21, 21, 21, 21, 21, 21, 21, 21, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_23_7_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_accepts_diff_23_7_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 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, 1, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_23_8_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_23_9_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_23_9_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 10, 0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0, }; unsigned char d_scanner_23_15_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, }; unsigned char d_scanner_23_15_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, }; D_Shift * d_shift_23_16_dparser_gram[] = {&d_shift_2_dparser_gram,NULL}; unsigned char d_scanner_23_19_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, }; unsigned char d_scanner_23_19_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, }; unsigned char d_scanner_23_20_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_23_22_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_23_22_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 28, 28, 28, 28, 28, 28, 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, 28, 28, 28, 28, 28, 28, 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, }; unsigned char d_scanner_23_27_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 28, 28, 28, 28, 28, 28, 0, 0, 0, 0, 0, 29, 0, 0, 0, 0, 0, 0, 0, 0, 29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 28, 28, 28, 28, 28, 0, 0, 0, 0, 0, 29, 0, 0, 0, 0, 0, 0, 0, 0, 29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_accepts_diff_32_0_dparser_gram[] = {0}; D_Shift * d_accepts_diff_32_1_dparser_gram[] = {&d_shift_75_dparser_gram,0}; D_Shift * d_accepts_diff_32_2_dparser_gram[] = {&d_shift_68_dparser_gram,0}; D_Shift ** d_accepts_diff_32_dparser_gram[] = { d_accepts_diff_32_0_dparser_gram, d_accepts_diff_32_1_dparser_gram, d_accepts_diff_32_2_dparser_gram }; unsigned char d_scanner_32_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 2, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 10, 2, 0, 2, 11, 2, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 12, 2, 13, 2, 0, }; unsigned char d_scanner_32_3_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 18, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, }; unsigned char d_scanner_32_3_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 19, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, }; unsigned char d_scanner_32_3_2_dparser_gram[SCANNER_BLOCK_SIZE] = { 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, }; unsigned char d_scanner_32_6_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 20, 20, 20, 20, 20, 20, 20, 20, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_32_6_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_32_7_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_32_12_dparser_gram[] = {&d_shift_4_dparser_gram,NULL}; unsigned char d_scanner_32_19_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_32_21_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_32_21_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 27, 27, 27, 27, 27, 27, 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, 27, 27, 27, 27, 27, 27, 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, }; unsigned char d_scanner_32_26_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 27, 27, 27, 27, 27, 27, 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 27, 27, 27, 27, 27, 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_accepts_diff_51_0_dparser_gram[] = {0}; D_Shift ** d_accepts_diff_51_dparser_gram[] = { d_accepts_diff_51_0_dparser_gram }; unsigned char d_scanner_51_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 2, 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, 0, 0, 3, 0, 0, }; D_Shift * d_accepts_diff_54_0_dparser_gram[] = {0}; D_Shift ** d_accepts_diff_54_dparser_gram[] = { d_accepts_diff_54_0_dparser_gram }; unsigned char d_scanner_54_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 2, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_54_1_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_54_2_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 6, 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, }; unsigned char d_scanner_54_3_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 7, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_54_4_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_54_5_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_54_6_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_54_7_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 12, 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, }; unsigned char d_scanner_54_8_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 13, 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, }; unsigned char d_scanner_54_9_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_54_10_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_54_11_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_54_12_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_54_13_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 19, 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, }; unsigned char d_scanner_54_15_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_54_16_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_54_17_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_54_18_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_54_19_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_54_20_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 26, 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, }; unsigned char d_scanner_54_22_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 28, 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, }; D_Shift * d_shift_54_23_dparser_gram[] = {&d_shift_13_dparser_gram,NULL}; unsigned char d_scanner_54_24_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 29, 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, }; D_Shift * d_shift_54_26_dparser_gram[] = {&d_shift_14_dparser_gram,NULL}; unsigned char d_scanner_54_27_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 31, 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, }; unsigned char d_scanner_54_28_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 32, 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, }; unsigned char d_scanner_54_29_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_54_30_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 34, 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, }; unsigned char d_scanner_54_31_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_54_32_dparser_gram[] = {&d_shift_11_dparser_gram,NULL}; unsigned char d_scanner_54_33_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_54_34_dparser_gram[] = {&d_shift_12_dparser_gram,NULL}; unsigned char d_scanner_54_35_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_54_37_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 39, 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, }; D_Shift * d_shift_54_38_dparser_gram[] = {&d_shift_15_dparser_gram,NULL}; D_Shift * d_accepts_diff_61_0_dparser_gram[] = {0}; D_Shift * d_accepts_diff_61_1_dparser_gram[] = {&d_shift_75_dparser_gram,0}; D_Shift * d_accepts_diff_61_2_dparser_gram[] = {&d_shift_68_dparser_gram,0}; D_Shift ** d_accepts_diff_61_dparser_gram[] = { d_accepts_diff_61_0_dparser_gram, d_accepts_diff_61_1_dparser_gram, d_accepts_diff_61_2_dparser_gram }; unsigned char d_scanner_61_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 2, 3, 2, 2, 2, 2, 4, 5, 6, 2, 2, 2, 7, 2, 2, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 2, 2, 2, 2, 2, 2, }; D_Shift * d_shift_61_5_dparser_gram[] = {&d_shift_34_dparser_gram,NULL}; D_Shift * d_accepts_diff_63_0_dparser_gram[] = {0}; D_Shift * d_accepts_diff_63_1_dparser_gram[] = {&d_shift_75_dparser_gram,0}; D_Shift * d_accepts_diff_63_2_dparser_gram[] = {&d_shift_68_dparser_gram,0}; D_Shift ** d_accepts_diff_63_dparser_gram[] = { d_accepts_diff_63_0_dparser_gram, d_accepts_diff_63_1_dparser_gram, d_accepts_diff_63_2_dparser_gram }; unsigned char d_scanner_63_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 2, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 10, 2, 11, 2, 12, 2, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 13, 2, 0, 2, 0, }; D_Shift * d_shift_63_10_dparser_gram[] = {&d_shift_61_dparser_gram,NULL}; D_Shift * d_accepts_diff_74_0_dparser_gram[] = {0}; D_Shift ** d_accepts_diff_74_dparser_gram[] = { d_accepts_diff_74_0_dparser_gram }; unsigned char d_scanner_74_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, }; D_Shift * d_accepts_diff_78_0_dparser_gram[] = {0}; D_Shift ** d_accepts_diff_78_dparser_gram[] = { d_accepts_diff_78_0_dparser_gram }; unsigned char d_scanner_78_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, }; D_Shift * d_accepts_diff_93_0_dparser_gram[] = {0}; D_Shift ** d_accepts_diff_93_dparser_gram[] = { d_accepts_diff_93_0_dparser_gram }; unsigned char d_scanner_93_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, }; D_Shift * d_shift_93_1_dparser_gram[] = {&d_shift_30_dparser_gram,NULL}; D_Shift * d_accepts_diff_96_0_dparser_gram[] = {0}; D_Shift * d_accepts_diff_96_1_dparser_gram[] = {&d_shift_72_dparser_gram,0}; D_Shift ** d_accepts_diff_96_dparser_gram[] = { d_accepts_diff_96_0_dparser_gram, d_accepts_diff_96_1_dparser_gram }; unsigned char d_scanner_96_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 2, 0, 3, 0, 0, 4, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_96_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 8, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 9, 0, 0, 0, 0, }; unsigned char d_scanner_96_1_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, }; unsigned char d_scanner_96_1_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 12, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, }; unsigned char d_scanner_96_1_2_dparser_gram[SCANNER_BLOCK_SIZE] = { 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, }; unsigned char d_scanner_96_2_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, }; unsigned char d_scanner_96_3_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, }; unsigned char d_scanner_96_5_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_96_5_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, }; unsigned char d_scanner_96_6_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 17, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, }; unsigned char d_accepts_diff_96_6_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_96_11_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, }; unsigned char d_scanner_96_12_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_96_15_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, }; unsigned char d_scanner_96_15_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, }; unsigned char d_scanner_96_16_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_96_16_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 21, 21, 21, 21, 21, 21, 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, 21, 21, 21, 21, 21, 21, 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, }; D_Shift * d_shift_96_20_dparser_gram[] = {&d_shift_71_dparser_gram,NULL}; unsigned char d_scanner_96_21_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 23, 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, }; unsigned char d_scanner_96_22_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_96_23_dparser_gram[] = {&d_shift_31_dparser_gram,NULL}; D_Shift * d_accepts_diff_100_0_dparser_gram[] = {0}; D_Shift * d_accepts_diff_100_1_dparser_gram[] = {&d_shift_55_dparser_gram,0}; D_Shift ** d_accepts_diff_100_dparser_gram[] = { d_accepts_diff_100_0_dparser_gram, d_accepts_diff_100_1_dparser_gram }; unsigned char d_scanner_100_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 2, 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, }; unsigned char d_scanner_100_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 3, 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, }; unsigned char d_scanner_100_1_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 6, 0, 0, 7, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, }; unsigned char d_scanner_100_3_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_4_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 10, 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, }; unsigned char d_scanner_100_5_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_6_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_7_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 13, 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, }; unsigned char d_scanner_100_8_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_9_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 15, 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, }; unsigned char d_scanner_100_10_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_11_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 17, 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, }; unsigned char d_scanner_100_12_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 18, 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, }; unsigned char d_scanner_100_14_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_15_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_16_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_17_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_18_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_100_19_dparser_gram[] = {&d_shift_53_dparser_gram,NULL}; unsigned char d_scanner_100_20_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_21_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_22_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 27, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_23_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_100_24_dparser_gram[] = {&d_shift_52_dparser_gram,NULL}; unsigned char d_scanner_100_25_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 29, 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, }; unsigned char d_scanner_100_26_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_28_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 32, 0, 0, 33, 0, 0, 34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_29_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_30_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 36, 0, 0, 37, 0, 0, 38, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_31_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 39, 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, }; unsigned char d_scanner_100_33_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 41, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_34_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 0, 0, }; unsigned char d_accepts_diff_100_34_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, }; D_Shift * d_shift_100_34_dparser_gram[] = {&d_shift_55_dparser_gram,NULL}; unsigned char d_scanner_100_35_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 43, 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, }; unsigned char d_scanner_100_36_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_37_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 45, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_38_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 46, 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, }; unsigned char d_scanner_100_39_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 47, 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, }; unsigned char d_scanner_100_40_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_100_41_dparser_gram[] = {&d_shift_54_dparser_gram,NULL}; unsigned char d_scanner_100_42_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 49, 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, }; unsigned char d_scanner_100_43_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 50, 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, }; unsigned char d_scanner_100_44_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_45_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_46_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 53, 0, 0, 0, 0, 0, 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_47_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_48_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_49_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 57, 0, 0, 0, 0, 0, 58, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_50_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 59, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_100_51_dparser_gram[] = {&d_shift_49_dparser_gram,NULL}; unsigned char d_scanner_100_52_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 60, 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, }; unsigned char d_scanner_100_53_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 61, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_54_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_100_55_dparser_gram[] = {&d_shift_51_dparser_gram,NULL}; unsigned char d_scanner_100_56_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 63, 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, }; unsigned char d_scanner_100_57_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_58_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_59_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 66, 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, }; unsigned char d_scanner_100_60_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 67, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_100_61_dparser_gram[] = {&d_shift_48_dparser_gram,NULL}; unsigned char d_scanner_100_62_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 68, 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, }; unsigned char d_scanner_100_63_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 69, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_100_64_dparser_gram[] = {&d_shift_50_dparser_gram,NULL}; unsigned char d_scanner_100_65_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 70, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_66_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 71, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_67_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 72, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_100_68_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 73, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_100_69_dparser_gram[] = {&d_shift_45_dparser_gram,NULL}; unsigned char d_scanner_100_70_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 74, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_100_71_dparser_gram[] = {&d_shift_47_dparser_gram,NULL}; D_Shift * d_shift_100_73_dparser_gram[] = {&d_shift_44_dparser_gram,NULL}; D_Shift * d_shift_100_74_dparser_gram[] = {&d_shift_46_dparser_gram,NULL}; D_Shift * d_accepts_diff_126_0_dparser_gram[] = {0}; D_Shift * d_accepts_diff_126_1_dparser_gram[] = {&d_shift_75_dparser_gram,0}; D_Shift ** d_accepts_diff_126_dparser_gram[] = { d_accepts_diff_126_0_dparser_gram, d_accepts_diff_126_1_dparser_gram }; unsigned char d_scanner_126_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 2, 0, 0, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_126_1_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_126_2_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_126_2_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_126_3_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_126_3_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_126_4_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_126_6_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 10, 10, 10, 10, 10, 10, 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, 10, 10, 10, 10, 10, 10, 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, }; unsigned char d_scanner_126_9_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_accepts_diff_131_0_dparser_gram[] = {0}; D_Shift ** d_accepts_diff_131_dparser_gram[] = { d_accepts_diff_131_0_dparser_gram }; D_Shift * d_accepts_diff_138_0_dparser_gram[] = {0}; D_Shift ** d_accepts_diff_138_dparser_gram[] = { d_accepts_diff_138_0_dparser_gram }; unsigned char d_scanner_138_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 2, 0, 0, 0, 0, 0, 3, 4, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, }; unsigned char d_scanner_138_0_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 7, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_138_1_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 8, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_138_2_dparser_gram[] = {&d_shift_39_dparser_gram,NULL}; D_Shift * d_shift_138_3_dparser_gram[] = {&d_shift_40_dparser_gram,NULL}; unsigned char d_scanner_138_4_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_138_5_dparser_gram[] = {&d_shift_38_dparser_gram,NULL}; D_Shift * d_shift_138_6_dparser_gram[] = {&d_shift_41_dparser_gram,NULL}; unsigned char d_scanner_138_7_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 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, 0, 0, }; D_Shift * d_shift_138_9_dparser_gram[] = {&d_shift_37_dparser_gram,NULL}; unsigned char d_scanner_138_10_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_138_11_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_138_12_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 15, 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, }; unsigned char d_scanner_138_13_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_shift_138_14_dparser_gram[] = {&d_shift_36_dparser_gram,NULL}; D_Shift * d_shift_138_15_dparser_gram[] = {&d_shift_35_dparser_gram,NULL}; D_Shift * d_accepts_diff_148_0_dparser_gram[] = {0}; D_Shift ** d_accepts_diff_148_dparser_gram[] = { d_accepts_diff_148_0_dparser_gram }; unsigned char d_scanner_148_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; D_Shift * d_accepts_diff_152_0_dparser_gram[] = {0}; D_Shift ** d_accepts_diff_152_dparser_gram[] = { d_accepts_diff_152_0_dparser_gram }; unsigned char d_scanner_152_0_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 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, 2, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; unsigned char d_scanner_152_1_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, }; unsigned char d_scanner_152_1_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, }; unsigned char d_scanner_152_1_2_dparser_gram[SCANNER_BLOCK_SIZE] = { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, }; unsigned char d_scanner_152_2_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, }; unsigned char d_scanner_152_2_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 9, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, }; unsigned char d_scanner_152_2_2_dparser_gram[SCANNER_BLOCK_SIZE] = { 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, }; unsigned char d_scanner_152_5_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, }; unsigned char d_scanner_152_8_0_dparser_gram[SCANNER_BLOCK_SIZE] = { 0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, }; unsigned char d_scanner_152_8_1_dparser_gram[SCANNER_BLOCK_SIZE] = { 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, }; D_Shift * d_accepts_diff_167_0_dparser_gram[] = {0}; D_Shift ** d_accepts_diff_167_dparser_gram[] = { d_accepts_diff_167_0_dparser_gram }; SB_uint8 d_scanner_2_dparser_gram[39] = { {NULL, {d_scanner_2_0_0_dparser_gram, d_scanner_2_0_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_1_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_2_0_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_3_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_4_dparser_gram, {d_scanner_2_4_0_dparser_gram, d_scanner_2_4_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_5_dparser_gram, {d_scanner_2_4_0_dparser_gram, d_scanner_2_4_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_4_dparser_gram, {d_scanner_2_4_0_dparser_gram, d_scanner_2_6_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_7_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_8_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_9_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_4_dparser_gram, {d_scanner_2_4_0_dparser_gram, d_scanner_2_10_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_11_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_12_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_13_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_14_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_4_dparser_gram, {d_scanner_2_4_0_dparser_gram, d_scanner_2_15_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_16_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_17_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_18_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_19_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_4_dparser_gram, {d_scanner_2_4_0_dparser_gram, d_scanner_2_20_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_21_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_22_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_23_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_24_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_4_dparser_gram, {d_scanner_2_4_0_dparser_gram, d_scanner_2_25_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_26_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_27_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_28_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_29_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_4_dparser_gram, {d_scanner_2_4_0_dparser_gram, d_scanner_2_30_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_31_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_32_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_33_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_34_dparser_gram, {d_scanner_2_4_0_dparser_gram, d_scanner_2_4_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_35_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_36_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_37_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_38_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_2_dparser_gram[39] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_5_0_dparser_gram, d_accepts_diff_2_5_1_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_34_0_dparser_gram, d_accepts_diff_2_34_1_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_3_dparser_gram[6] = { {NULL, {d_scanner_3_0_0_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_3_1_0_dparser_gram, d_scanner_3_1_1_dparser_gram , d_scanner_3_1_2_dparser_gram, d_scanner_3_1_2_dparser_gram}}, {NULL, {d_scanner_3_1_0_dparser_gram, d_scanner_3_1_1_dparser_gram , d_scanner_3_1_2_dparser_gram, d_scanner_3_1_2_dparser_gram}}, {d_shift_3_3_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_3_4_0_dparser_gram, d_scanner_3_4_1_dparser_gram , d_scanner_3_4_1_dparser_gram, d_scanner_3_4_1_dparser_gram}}, {NULL, {d_scanner_3_1_0_dparser_gram, d_scanner_3_1_1_dparser_gram , d_scanner_3_1_2_dparser_gram, d_scanner_3_1_2_dparser_gram}} }; SB_trans_uint8 d_transition_3_dparser_gram[6] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_5_dparser_gram[27] = { {NULL, {d_scanner_5_0_0_dparser_gram, d_scanner_5_0_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_1_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_5_2_0_dparser_gram, d_scanner_5_2_1_dparser_gram , d_scanner_5_2_2_dparser_gram, d_scanner_5_2_2_dparser_gram}}, {NULL, {d_scanner_5_3_0_dparser_gram, d_scanner_5_3_1_dparser_gram , d_scanner_5_3_2_dparser_gram, d_scanner_5_3_2_dparser_gram}}, {d_shift_5_4_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_1_dparser_gram, {d_scanner_5_5_0_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_6_dparser_gram, {d_scanner_5_6_0_dparser_gram, d_scanner_5_6_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_7_dparser_gram, {d_scanner_5_7_0_dparser_gram, d_scanner_5_7_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_4_dparser_gram, {d_scanner_5_8_0_dparser_gram, d_scanner_5_8_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_9_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_1_dparser_gram, {d_scanner_5_8_0_dparser_gram, d_scanner_5_8_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_7_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_5_2_0_dparser_gram, d_scanner_5_2_1_dparser_gram , d_scanner_5_2_2_dparser_gram, d_scanner_5_2_2_dparser_gram}}, {d_shift_3_3_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_5_14_0_dparser_gram, d_scanner_5_14_1_dparser_gram , d_scanner_5_14_1_dparser_gram, d_scanner_5_14_1_dparser_gram}}, {NULL, {d_scanner_5_3_0_dparser_gram, d_scanner_5_3_1_dparser_gram , d_scanner_5_3_2_dparser_gram, d_scanner_5_3_2_dparser_gram}}, {d_shift_5_16_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_5_17_0_dparser_gram, d_scanner_5_17_1_dparser_gram , d_scanner_5_17_1_dparser_gram, d_scanner_5_17_1_dparser_gram}}, {d_shift_5_6_dparser_gram, {d_scanner_5_6_0_dparser_gram, d_scanner_5_18_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_6_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_5_20_0_dparser_gram, d_scanner_5_20_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_5_20_0_dparser_gram, d_scanner_5_20_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_7_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_5_2_0_dparser_gram, d_scanner_5_2_1_dparser_gram , d_scanner_5_2_2_dparser_gram, d_scanner_5_2_2_dparser_gram}}, {NULL, {d_scanner_5_3_0_dparser_gram, d_scanner_5_3_1_dparser_gram , d_scanner_5_3_2_dparser_gram, d_scanner_5_3_2_dparser_gram}}, {d_shift_5_25_dparser_gram, {d_scanner_5_20_0_dparser_gram, d_scanner_5_25_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_25_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_5_dparser_gram[27] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_34_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_5_6_1_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_34_0_dparser_gram, d_accepts_diff_2_34_1_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_6_dparser_gram[100] = { {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_0_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_1_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_2_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_3_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_4_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_5_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_6_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_7_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_8_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_9_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_10_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_11_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_12_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_13_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_14_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_15_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_16_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_17_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_18_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_19_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_20_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_24_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_22_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_23_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_24_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_29_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_26_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_27_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_28_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_29_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_30_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_31_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_32_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_33_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_34_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_35_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_36_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_37_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_38_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_39_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_40_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_41_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_42_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_43_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_44_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_45_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_46_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_47_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_48_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_49_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_50_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_51_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_52_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_53_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_54_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_55_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_56_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_6_57_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_58_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_59_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_60_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_61_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_62_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_63_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_6_64_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_65_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_66_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_67_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_68_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_69_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_70_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_6_71_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_6_72_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_73_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_74_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_75_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_76_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_77_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_78_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_79_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_80_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_81_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_6_82_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_83_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_84_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_6_85_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_86_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_87_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_6_88_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_89_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_90_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_91_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_92_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_93_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_94_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_95_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_96_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_97_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_98_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_6_99_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_6_dparser_gram[100] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_7_dparser_gram[2] = { {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_7_0_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_4_dparser_gram, {d_scanner_7_1_0_dparser_gram, d_scanner_7_0_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_7_dparser_gram[2] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_17_dparser_gram[4] = { {NULL, {d_scanner_17_0_0_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_17_1_dparser_gram, {d_scanner_17_1_0_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_17_2_0_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_17_3_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_17_dparser_gram[4] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_17_1_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_23_dparser_gram[29] = { {NULL, {d_scanner_23_0_0_dparser_gram, d_scanner_23_0_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_1_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_2_0_dparser_gram, d_scanner_23_2_1_dparser_gram , d_scanner_23_2_2_dparser_gram, d_scanner_23_2_2_dparser_gram}}, {d_shift_5_1_dparser_gram, {d_scanner_23_3_0_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_4_0_dparser_gram, d_scanner_23_4_1_dparser_gram , d_scanner_23_4_2_dparser_gram, d_scanner_23_4_2_dparser_gram}}, {d_shift_5_4_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_1_dparser_gram, {d_scanner_23_6_0_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_6_dparser_gram, {d_scanner_23_7_0_dparser_gram, d_scanner_23_7_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_7_dparser_gram, {d_scanner_5_8_0_dparser_gram, d_scanner_23_8_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_4_dparser_gram, {d_scanner_23_9_0_dparser_gram, d_scanner_23_9_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_9_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_1_dparser_gram, {d_scanner_23_9_0_dparser_gram, d_scanner_23_9_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_7_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_2_0_dparser_gram, d_scanner_23_2_1_dparser_gram , d_scanner_23_2_2_dparser_gram, d_scanner_23_2_2_dparser_gram}}, {d_shift_3_3_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_15_0_dparser_gram, d_scanner_23_15_1_dparser_gram , d_scanner_23_15_1_dparser_gram, d_scanner_23_15_1_dparser_gram}}, {d_shift_23_16_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_4_0_dparser_gram, d_scanner_23_4_1_dparser_gram , d_scanner_23_4_2_dparser_gram, d_scanner_23_4_2_dparser_gram}}, {d_shift_5_16_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_19_0_dparser_gram, d_scanner_23_19_1_dparser_gram , d_scanner_23_19_1_dparser_gram, d_scanner_23_19_1_dparser_gram}}, {d_shift_5_6_dparser_gram, {d_scanner_23_7_0_dparser_gram, d_scanner_23_20_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_6_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_22_0_dparser_gram, d_scanner_23_22_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_22_0_dparser_gram, d_scanner_23_22_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_7_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_2_0_dparser_gram, d_scanner_23_2_1_dparser_gram , d_scanner_23_2_2_dparser_gram, d_scanner_23_2_2_dparser_gram}}, {NULL, {d_scanner_23_4_0_dparser_gram, d_scanner_23_4_1_dparser_gram , d_scanner_23_4_2_dparser_gram, d_scanner_23_4_2_dparser_gram}}, {d_shift_5_25_dparser_gram, {d_scanner_23_22_0_dparser_gram, d_scanner_23_27_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_25_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_23_dparser_gram[29] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_23_3_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_5_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_23_7_1_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_5_0_dparser_gram, d_accepts_diff_2_5_1_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_32_dparser_gram[28] = { {NULL, {d_scanner_5_0_0_dparser_gram, d_scanner_32_0_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_1_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_2_0_dparser_gram, d_scanner_23_2_1_dparser_gram , d_scanner_23_2_2_dparser_gram, d_scanner_23_2_2_dparser_gram}}, {NULL, {d_scanner_32_3_0_dparser_gram, d_scanner_32_3_1_dparser_gram , d_scanner_32_3_2_dparser_gram, d_scanner_32_3_2_dparser_gram}}, {d_shift_5_4_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_1_dparser_gram, {d_scanner_5_5_0_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_6_dparser_gram, {d_scanner_32_6_0_dparser_gram, d_scanner_32_6_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_7_dparser_gram, {d_scanner_5_7_0_dparser_gram, d_scanner_32_7_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_4_dparser_gram, {d_scanner_5_8_0_dparser_gram, d_scanner_5_8_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_9_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_1_dparser_gram, {d_scanner_5_8_0_dparser_gram, d_scanner_5_8_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_7_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_32_12_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_2_0_dparser_gram, d_scanner_23_2_1_dparser_gram , d_scanner_23_2_2_dparser_gram, d_scanner_23_2_2_dparser_gram}}, {d_shift_3_3_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_5_17_0_dparser_gram, d_scanner_5_17_1_dparser_gram , d_scanner_5_17_1_dparser_gram, d_scanner_5_17_1_dparser_gram}}, {NULL, {d_scanner_32_3_0_dparser_gram, d_scanner_32_3_1_dparser_gram , d_scanner_32_3_2_dparser_gram, d_scanner_32_3_2_dparser_gram}}, {d_shift_5_16_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_15_0_dparser_gram, d_scanner_23_15_1_dparser_gram , d_scanner_23_15_1_dparser_gram, d_scanner_23_15_1_dparser_gram}}, {d_shift_5_6_dparser_gram, {d_scanner_32_6_0_dparser_gram, d_scanner_32_19_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_6_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_32_21_0_dparser_gram, d_scanner_32_21_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_32_21_0_dparser_gram, d_scanner_32_21_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_7_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_2_0_dparser_gram, d_scanner_23_2_1_dparser_gram , d_scanner_23_2_2_dparser_gram, d_scanner_23_2_2_dparser_gram}}, {NULL, {d_scanner_32_3_0_dparser_gram, d_scanner_32_3_1_dparser_gram , d_scanner_32_3_2_dparser_gram, d_scanner_32_3_2_dparser_gram}}, {d_shift_5_25_dparser_gram, {d_scanner_32_21_0_dparser_gram, d_scanner_32_26_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_25_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_32_dparser_gram[28] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_5_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_23_7_1_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_5_0_dparser_gram, d_accepts_diff_2_5_1_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_51_dparser_gram[3] = { {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_51_0_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_4_dparser_gram, {d_scanner_7_1_0_dparser_gram, d_scanner_7_0_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_32_12_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_51_dparser_gram[3] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_54_dparser_gram[39] = { {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_0_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_1_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_2_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_3_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_4_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_5_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_6_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_7_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_8_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_9_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_10_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_11_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_12_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_13_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_14_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_15_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_16_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_17_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_18_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_19_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_20_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_21_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_22_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_54_23_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_24_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_24_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_54_26_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_27_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_28_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_29_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_30_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_31_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_54_32_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_33_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_54_34_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_35_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_35_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_37_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_54_38_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_54_dparser_gram[39] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_61_dparser_gram[28] = { {NULL, {d_scanner_61_0_0_dparser_gram, d_scanner_23_0_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_1_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_2_0_dparser_gram, d_scanner_23_2_1_dparser_gram , d_scanner_23_2_2_dparser_gram, d_scanner_23_2_2_dparser_gram}}, {NULL, {d_scanner_32_3_0_dparser_gram, d_scanner_32_3_1_dparser_gram , d_scanner_32_3_2_dparser_gram, d_scanner_32_3_2_dparser_gram}}, {d_shift_5_4_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_61_5_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_1_dparser_gram, {d_scanner_23_6_0_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_6_dparser_gram, {d_scanner_32_6_0_dparser_gram, d_scanner_32_6_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_7_dparser_gram, {d_scanner_5_8_0_dparser_gram, d_scanner_32_7_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_4_dparser_gram, {d_scanner_23_9_0_dparser_gram, d_scanner_23_9_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_9_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_1_dparser_gram, {d_scanner_23_9_0_dparser_gram, d_scanner_23_9_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_7_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_2_0_dparser_gram, d_scanner_23_2_1_dparser_gram , d_scanner_23_2_2_dparser_gram, d_scanner_23_2_2_dparser_gram}}, {d_shift_3_3_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_5_17_0_dparser_gram, d_scanner_5_17_1_dparser_gram , d_scanner_5_17_1_dparser_gram, d_scanner_5_17_1_dparser_gram}}, {NULL, {d_scanner_32_3_0_dparser_gram, d_scanner_32_3_1_dparser_gram , d_scanner_32_3_2_dparser_gram, d_scanner_32_3_2_dparser_gram}}, {d_shift_5_16_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_15_0_dparser_gram, d_scanner_23_15_1_dparser_gram , d_scanner_23_15_1_dparser_gram, d_scanner_23_15_1_dparser_gram}}, {d_shift_5_6_dparser_gram, {d_scanner_32_6_0_dparser_gram, d_scanner_32_19_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_6_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_32_21_0_dparser_gram, d_scanner_32_21_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_32_21_0_dparser_gram, d_scanner_32_21_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_7_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_2_0_dparser_gram, d_scanner_23_2_1_dparser_gram , d_scanner_23_2_2_dparser_gram, d_scanner_23_2_2_dparser_gram}}, {NULL, {d_scanner_32_3_0_dparser_gram, d_scanner_32_3_1_dparser_gram , d_scanner_32_3_2_dparser_gram, d_scanner_32_3_2_dparser_gram}}, {d_shift_5_25_dparser_gram, {d_scanner_32_21_0_dparser_gram, d_scanner_32_26_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_25_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_61_dparser_gram[28] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_5_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_23_7_1_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_5_0_dparser_gram, d_accepts_diff_2_5_1_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_63_dparser_gram[28] = { {NULL, {d_scanner_5_0_0_dparser_gram, d_scanner_63_0_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_1_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_2_0_dparser_gram, d_scanner_23_2_1_dparser_gram , d_scanner_23_2_2_dparser_gram, d_scanner_23_2_2_dparser_gram}}, {NULL, {d_scanner_32_3_0_dparser_gram, d_scanner_32_3_1_dparser_gram , d_scanner_32_3_2_dparser_gram, d_scanner_32_3_2_dparser_gram}}, {d_shift_5_4_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_1_dparser_gram, {d_scanner_5_5_0_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_6_dparser_gram, {d_scanner_32_6_0_dparser_gram, d_scanner_32_6_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_7_dparser_gram, {d_scanner_5_7_0_dparser_gram, d_scanner_32_7_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_4_dparser_gram, {d_scanner_5_8_0_dparser_gram, d_scanner_5_8_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_9_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_63_10_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_1_dparser_gram, {d_scanner_5_8_0_dparser_gram, d_scanner_5_8_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_7_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_2_0_dparser_gram, d_scanner_23_2_1_dparser_gram , d_scanner_23_2_2_dparser_gram, d_scanner_23_2_2_dparser_gram}}, {d_shift_3_3_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_5_17_0_dparser_gram, d_scanner_5_17_1_dparser_gram , d_scanner_5_17_1_dparser_gram, d_scanner_5_17_1_dparser_gram}}, {NULL, {d_scanner_32_3_0_dparser_gram, d_scanner_32_3_1_dparser_gram , d_scanner_32_3_2_dparser_gram, d_scanner_32_3_2_dparser_gram}}, {d_shift_5_16_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_15_0_dparser_gram, d_scanner_23_15_1_dparser_gram , d_scanner_23_15_1_dparser_gram, d_scanner_23_15_1_dparser_gram}}, {d_shift_5_6_dparser_gram, {d_scanner_32_6_0_dparser_gram, d_scanner_32_19_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_6_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_32_21_0_dparser_gram, d_scanner_32_21_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_32_21_0_dparser_gram, d_scanner_32_21_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_7_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_2_0_dparser_gram, d_scanner_23_2_1_dparser_gram , d_scanner_23_2_2_dparser_gram, d_scanner_23_2_2_dparser_gram}}, {NULL, {d_scanner_32_3_0_dparser_gram, d_scanner_32_3_1_dparser_gram , d_scanner_32_3_2_dparser_gram, d_scanner_32_3_2_dparser_gram}}, {d_shift_5_25_dparser_gram, {d_scanner_32_21_0_dparser_gram, d_scanner_32_26_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_25_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_63_dparser_gram[28] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_5_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_23_7_1_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_5_0_dparser_gram, d_accepts_diff_2_5_1_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_74_dparser_gram[2] = { {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_74_0_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_32_12_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_74_dparser_gram[2] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_78_dparser_gram[2] = { {NULL, {d_scanner_78_0_0_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_3_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_78_dparser_gram[2] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_93_dparser_gram[2] = { {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_93_0_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_93_1_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_93_dparser_gram[2] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_96_dparser_gram[24] = { {NULL, {d_scanner_96_0_0_dparser_gram, d_scanner_96_0_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_96_1_0_dparser_gram, d_scanner_96_1_1_dparser_gram , d_scanner_96_1_2_dparser_gram, d_scanner_96_1_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_96_2_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_96_3_0_dparser_gram, d_scanner_23_2_1_dparser_gram , d_scanner_23_2_2_dparser_gram, d_scanner_23_2_2_dparser_gram}}, {d_shift_5_4_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_4_dparser_gram, {d_scanner_96_5_0_dparser_gram, d_scanner_96_5_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_4_dparser_gram, {d_scanner_96_6_0_dparser_gram, d_scanner_96_5_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_9_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_7_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_96_1_0_dparser_gram, d_scanner_96_1_1_dparser_gram , d_scanner_96_1_2_dparser_gram, d_scanner_96_1_2_dparser_gram}}, {d_shift_3_3_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_96_11_0_dparser_gram, d_scanner_23_4_2_dparser_gram , d_scanner_23_4_2_dparser_gram, d_scanner_23_4_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_96_12_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_96_3_0_dparser_gram, d_scanner_23_2_1_dparser_gram , d_scanner_23_2_2_dparser_gram, d_scanner_23_2_2_dparser_gram}}, {d_shift_5_16_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_96_15_0_dparser_gram, d_scanner_96_15_1_dparser_gram , d_scanner_96_15_1_dparser_gram, d_scanner_96_15_1_dparser_gram}}, {NULL, {d_scanner_96_16_0_dparser_gram, d_scanner_96_16_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_96_1_0_dparser_gram, d_scanner_96_1_1_dparser_gram , d_scanner_96_1_2_dparser_gram, d_scanner_96_1_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_2_16_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_96_3_0_dparser_gram, d_scanner_23_2_1_dparser_gram , d_scanner_23_2_2_dparser_gram, d_scanner_23_2_2_dparser_gram}}, {d_shift_96_20_dparser_gram, {d_scanner_96_16_0_dparser_gram, d_scanner_96_16_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_96_21_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_96_22_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_96_23_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_96_dparser_gram[24] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_96_6_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_100_dparser_gram[75] = { {NULL, {d_scanner_100_0_0_dparser_gram, d_scanner_100_0_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_1_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_9_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_3_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_4_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_5_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_6_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_7_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_8_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_9_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_10_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_11_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_12_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_13_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_14_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_15_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_16_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_17_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_18_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_100_19_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_20_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_21_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_22_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_23_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_100_24_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_25_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_26_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_22_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_28_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_29_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_30_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_31_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_31_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_33_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_100_34_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_100_34_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_35_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_36_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_37_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_38_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_39_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_40_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_100_41_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_42_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_43_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_44_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_45_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_46_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_47_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_48_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_49_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_50_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_100_51_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_52_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_53_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_54_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_100_55_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_56_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_57_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_58_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_59_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_60_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_100_61_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_62_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_63_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_100_64_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_65_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_66_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_67_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_68_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_100_69_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_100_70_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_100_71_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_6_68_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_100_73_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_100_74_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_100_dparser_gram[75] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_100_34_1_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_126_dparser_gram[11] = { {NULL, {d_scanner_126_0_0_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_126_1_0_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_6_dparser_gram, {d_scanner_126_2_0_dparser_gram, d_scanner_126_2_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_7_dparser_gram, {d_scanner_126_3_0_dparser_gram, d_scanner_126_3_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_6_dparser_gram, {d_scanner_126_2_0_dparser_gram, d_scanner_126_4_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_6_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_9_0_dparser_gram, d_scanner_126_6_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_23_9_0_dparser_gram, d_scanner_126_6_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_7_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_25_dparser_gram, {d_scanner_23_9_0_dparser_gram, d_scanner_126_9_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_5_25_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_126_dparser_gram[11] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_23_7_1_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_131_dparser_gram[2] = { {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_78_0_0_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_2_7_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_131_dparser_gram[2] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_138_dparser_gram[16] = { {NULL, {d_scanner_138_0_0_dparser_gram, d_scanner_138_0_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_138_1_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_138_2_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_138_3_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_138_4_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_138_5_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_138_6_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_138_7_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_54_7_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_138_9_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_138_10_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_138_11_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_138_12_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_2_0_2_dparser_gram, d_scanner_138_13_1_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_138_14_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_138_15_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_138_dparser_gram[16] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_148_dparser_gram[2] = { {NULL, {d_scanner_148_0_0_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_61_5_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_148_dparser_gram[2] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_152_dparser_gram[11] = { {NULL, {d_scanner_152_0_0_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_152_1_0_dparser_gram, d_scanner_152_1_1_dparser_gram , d_scanner_152_1_2_dparser_gram, d_scanner_152_1_2_dparser_gram}}, {NULL, {d_scanner_152_2_0_dparser_gram, d_scanner_152_2_1_dparser_gram , d_scanner_152_2_2_dparser_gram, d_scanner_152_2_2_dparser_gram}}, {NULL, {d_scanner_152_1_0_dparser_gram, d_scanner_152_1_1_dparser_gram , d_scanner_152_1_2_dparser_gram, d_scanner_152_1_2_dparser_gram}}, {d_shift_3_3_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_152_5_0_dparser_gram, d_scanner_96_1_2_dparser_gram , d_scanner_96_1_2_dparser_gram, d_scanner_96_1_2_dparser_gram}}, {NULL, {d_scanner_152_2_0_dparser_gram, d_scanner_152_2_1_dparser_gram , d_scanner_152_2_2_dparser_gram, d_scanner_152_2_2_dparser_gram}}, {d_shift_5_16_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {NULL, {d_scanner_152_8_0_dparser_gram, d_scanner_152_8_1_dparser_gram , d_scanner_152_8_1_dparser_gram, d_scanner_152_8_1_dparser_gram}}, {NULL, {d_scanner_152_1_0_dparser_gram, d_scanner_152_1_1_dparser_gram , d_scanner_152_1_2_dparser_gram, d_scanner_152_1_2_dparser_gram}}, {NULL, {d_scanner_152_2_0_dparser_gram, d_scanner_152_2_1_dparser_gram , d_scanner_152_2_2_dparser_gram, d_scanner_152_2_2_dparser_gram}} }; SB_trans_uint8 d_transition_152_dparser_gram[11] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; SB_uint8 d_scanner_167_dparser_gram[2] = { {NULL, {d_scanner_17_0_0_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}}, {d_shift_17_1_dparser_gram, {d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram , d_scanner_2_0_2_dparser_gram, d_scanner_2_0_2_dparser_gram}} }; SB_trans_uint8 d_transition_167_dparser_gram[2] = { {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}}, {{d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram , d_accepts_diff_2_0_0_dparser_gram, d_accepts_diff_2_0_0_dparser_gram}} }; unsigned char d_goto_valid_0_dparser_gram[] = { 0x6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_0_dparser_gram[] = {&d_reduction_3_dparser_gram}; D_RightEpsilonHint d_right_epsilon_hints_0_dparser_gram[] = {{0, 1, &d_reduction_0_dparser_gram},{0, 2, &d_reduction_1_dparser_gram}}; unsigned char d_goto_valid_2_dparser_gram[] = { 0x38,0x40,0x3,0x0,0x0,0x80,0x0,0x8,0xab,0x2,0x0,0x22,0x0,0x0,0x0,0x4,0x0,0x1}; D_Reduction * d_reductions_2_dparser_gram[] = {&d_reduction_1_dparser_gram}; unsigned char d_goto_valid_3_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0}; unsigned char d_goto_valid_4_dparser_gram[] = { 0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_4_dparser_gram[] = {&d_reduction_21_dparser_gram}; unsigned char d_goto_valid_5_dparser_gram[] = { 0x0,0x1,0x0,0x0,0x0,0x0,0x88,0xfb,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x14,0x70,0xf}; unsigned char d_goto_valid_6_dparser_gram[] = { 0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_7_dparser_gram[] = { 0x40,0x20,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1}; unsigned char d_goto_valid_8_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1}; D_Reduction * d_reductions_9_dparser_gram[] = {&d_reduction_40_dparser_gram}; D_Reduction * d_reductions_10_dparser_gram[] = {&d_reduction_43_dparser_gram}; unsigned char d_goto_valid_11_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_11_dparser_gram[] = {&d_reduction_112_dparser_gram}; D_Reduction * d_reductions_12_dparser_gram[] = {&d_reduction_134_dparser_gram}; D_Reduction * d_reductions_13_dparser_gram[] = {&d_reduction_2_dparser_gram}; D_Reduction * d_reductions_14_dparser_gram[] = {&d_reduction_4_dparser_gram}; D_Reduction * d_reductions_15_dparser_gram[] = {&d_reduction_4_dparser_gram}; D_Reduction * d_reductions_16_dparser_gram[] = {&d_reduction_4_dparser_gram}; unsigned char d_goto_valid_17_dparser_gram[] = { 0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x11,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_18_dparser_gram[] = {&d_reduction_42_dparser_gram}; D_Reduction * d_reductions_19_dparser_gram[] = {&d_reduction_9_dparser_gram}; D_Reduction * d_reductions_20_dparser_gram[] = {&d_reduction_43_dparser_gram}; D_Reduction * d_reductions_21_dparser_gram[] = {&d_reduction_132_dparser_gram}; D_Reduction * d_reductions_22_dparser_gram[] = {&d_reduction_7_dparser_gram}; unsigned char d_goto_valid_23_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x88,0xfb,0x4,0x0,0x0,0x0,0x2,0x0,0x0,0x14,0x70,0xf}; unsigned char d_goto_valid_24_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_24_dparser_gram[] = {&d_reduction_129_dparser_gram}; unsigned char d_goto_valid_25_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_25_dparser_gram[] = {&d_reduction_125_dparser_gram}; unsigned char d_goto_valid_26_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_26_dparser_gram[] = {&d_reduction_127_dparser_gram}; D_Reduction * d_reductions_27_dparser_gram[] = {&d_reduction_130_dparser_gram}; D_Reduction * d_reductions_28_dparser_gram[] = {&d_reduction_131_dparser_gram}; D_Reduction * d_reductions_29_dparser_gram[] = {&d_reduction_138_dparser_gram}; D_Reduction * d_reductions_30_dparser_gram[] = {&d_reduction_139_dparser_gram}; D_Reduction * d_reductions_31_dparser_gram[] = {&d_reduction_140_dparser_gram}; unsigned char d_goto_valid_32_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x88,0xfb,0x10,0x0,0x0,0x0,0x2,0x0,0x0,0x14,0x70,0xf}; D_Reduction * d_reductions_33_dparser_gram[] = {&d_reduction_19_dparser_gram}; D_Reduction * d_reductions_34_dparser_gram[] = {&d_reduction_119_dparser_gram}; D_Reduction * d_reductions_35_dparser_gram[] = {&d_reduction_119_dparser_gram}; D_Reduction * d_reductions_36_dparser_gram[] = {&d_reduction_119_dparser_gram}; D_Reduction * d_reductions_37_dparser_gram[] = {&d_reduction_119_dparser_gram}; D_Reduction * d_reductions_38_dparser_gram[] = {&d_reduction_119_dparser_gram}; D_Reduction * d_reductions_39_dparser_gram[] = {&d_reduction_135_dparser_gram}; D_Reduction * d_reductions_40_dparser_gram[] = {&d_reduction_135_dparser_gram}; D_Reduction * d_reductions_41_dparser_gram[] = {&d_reduction_135_dparser_gram}; D_Reduction * d_reductions_42_dparser_gram[] = {&d_reduction_29_dparser_gram}; D_Reduction * d_reductions_43_dparser_gram[] = {&d_reduction_30_dparser_gram}; D_Reduction * d_reductions_44_dparser_gram[] = {&d_reduction_31_dparser_gram}; D_Reduction * d_reductions_45_dparser_gram[] = {&d_reduction_32_dparser_gram}; D_Reduction * d_reductions_46_dparser_gram[] = {&d_reduction_33_dparser_gram}; D_Reduction * d_reductions_47_dparser_gram[] = {&d_reduction_34_dparser_gram}; D_Reduction * d_reductions_48_dparser_gram[] = {&d_reduction_35_dparser_gram}; D_Reduction * d_reductions_49_dparser_gram[] = {&d_reduction_36_dparser_gram}; unsigned char d_goto_valid_50_dparser_gram[] = { 0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_50_dparser_gram[] = {&d_reduction_17_dparser_gram}; unsigned char d_goto_valid_51_dparser_gram[] = { 0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x8,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1}; D_Reduction * d_reductions_52_dparser_gram[] = {&d_reduction_15_dparser_gram}; D_Reduction * d_reductions_53_dparser_gram[] = {&d_reduction_37_dparser_gram}; unsigned char d_goto_valid_54_dparser_gram[] = { 0x0,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_54_dparser_gram[] = {&d_reduction_22_dparser_gram}; unsigned char d_goto_valid_55_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x88,0xfb,0x10,0x0,0x0,0x0,0x2,0x0,0x0,0x14,0x70,0xf}; unsigned char d_goto_valid_56_dparser_gram[] = { 0x0,0x0,0x24,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_56_dparser_gram[] = {&d_reduction_62_dparser_gram}; D_RightEpsilonHint d_right_epsilon_hints_56_dparser_gram[] = {{1, 93, &d_reduction_45_dparser_gram},{3, 130, &d_reduction_49_dparser_gram}}; D_Reduction * d_reductions_57_dparser_gram[] = {&d_reduction_41_dparser_gram}; unsigned char d_goto_valid_58_dparser_gram[] = { 0x0,0x0,0x24,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_58_dparser_gram[] = {&d_reduction_62_dparser_gram}; D_RightEpsilonHint d_right_epsilon_hints_58_dparser_gram[] = {{1, 93, &d_reduction_45_dparser_gram},{3, 130, &d_reduction_49_dparser_gram}}; D_Reduction * d_reductions_59_dparser_gram[] = {&d_reduction_8_dparser_gram}; D_Reduction * d_reductions_60_dparser_gram[] = {&d_reduction_20_dparser_gram}; unsigned char d_goto_valid_61_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x88,0xfb,0x0,0x0,0x0,0x0,0x6,0x0,0x0,0x14,0x70,0xf}; unsigned char d_goto_valid_62_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x88,0xfb,0x10,0x0,0x0,0x0,0x2,0x0,0x0,0x14,0x70,0xf}; unsigned char d_goto_valid_63_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x88,0xfb,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x34,0x70,0xf}; D_Reduction * d_reductions_64_dparser_gram[] = {&d_reduction_10_dparser_gram}; D_Reduction * d_reductions_65_dparser_gram[] = {&d_reduction_18_dparser_gram}; unsigned char d_goto_valid_66_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1}; D_Reduction * d_reductions_67_dparser_gram[] = {&d_reduction_12_dparser_gram}; D_Reduction * d_reductions_68_dparser_gram[] = {&d_reduction_14_dparser_gram}; D_Reduction * d_reductions_69_dparser_gram[] = {&d_reduction_24_dparser_gram}; D_Reduction * d_reductions_70_dparser_gram[] = {&d_reduction_25_dparser_gram}; D_Reduction * d_reductions_71_dparser_gram[] = {&d_reduction_26_dparser_gram}; D_Reduction * d_reductions_72_dparser_gram[] = {&d_reduction_27_dparser_gram}; D_Reduction * d_reductions_73_dparser_gram[] = {&d_reduction_28_dparser_gram}; unsigned char d_goto_valid_74_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_75_dparser_gram[] = { 0x0,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_75_dparser_gram[] = {&d_reduction_22_dparser_gram}; D_RightEpsilonHint d_right_epsilon_hints_75_dparser_gram[] = {{0, 91, &d_reduction_23_dparser_gram}}; D_Reduction * d_reductions_76_dparser_gram[] = {&d_reduction_110_dparser_gram}; D_Reduction * d_reductions_77_dparser_gram[] = {&d_reduction_111_dparser_gram}; unsigned char d_goto_valid_78_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_79_dparser_gram[] = { 0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_79_dparser_gram[] = {&d_reduction_47_dparser_gram}; D_RightEpsilonHint d_right_epsilon_hints_79_dparser_gram[] = {{0, 93, &d_reduction_45_dparser_gram}}; unsigned char d_goto_valid_80_dparser_gram[] = { 0x0,0x0,0x80,0x5,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_80_dparser_gram[] = {&d_reduction_53_dparser_gram,&d_reduction_58_dparser_gram}; D_RightEpsilonHint d_right_epsilon_hints_80_dparser_gram[] = {{2, 130, &d_reduction_49_dparser_gram}}; unsigned char d_goto_valid_81_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_82_dparser_gram[] = {&d_reduction_116_dparser_gram}; D_Reduction * d_reductions_83_dparser_gram[] = {&d_reduction_128_dparser_gram}; D_Reduction * d_reductions_84_dparser_gram[] = {&d_reduction_116_dparser_gram}; D_Reduction * d_reductions_85_dparser_gram[] = {&d_reduction_124_dparser_gram}; D_Reduction * d_reductions_86_dparser_gram[] = {&d_reduction_116_dparser_gram}; D_Reduction * d_reductions_87_dparser_gram[] = {&d_reduction_126_dparser_gram}; D_Reduction * d_reductions_88_dparser_gram[] = {&d_reduction_11_dparser_gram}; D_Reduction * d_reductions_89_dparser_gram[] = {&d_reduction_16_dparser_gram}; D_Reduction * d_reductions_90_dparser_gram[] = {&d_reduction_13_dparser_gram}; D_Reduction * d_reductions_91_dparser_gram[] = {&d_reduction_23_dparser_gram}; D_Reduction * d_reductions_92_dparser_gram[] = {&d_reduction_38_dparser_gram}; unsigned char d_goto_valid_93_dparser_gram[] = { 0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_93_dparser_gram[] = {&d_reduction_45_dparser_gram}; unsigned char d_goto_valid_94_dparser_gram[] = { 0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_94_dparser_gram[] = {&d_reduction_51_dparser_gram}; D_RightEpsilonHint d_right_epsilon_hints_94_dparser_gram[] = {{1, 130, &d_reduction_49_dparser_gram}}; D_Reduction * d_reductions_95_dparser_gram[] = {&d_reduction_52_dparser_gram}; unsigned char d_goto_valid_96_dparser_gram[] = { 0x0,0x0,0x0,0x48,0x1,0x80,0x2,0xf,0x0,0x0,0x0,0x80,0x2,0x0,0x0,0x14,0xe0,0x1}; D_Reduction * d_reductions_97_dparser_gram[] = {&d_reduction_38_dparser_gram}; unsigned char d_goto_valid_98_dparser_gram[] = { 0x0,0x0,0x20,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_98_dparser_gram[] = {&d_reduction_62_dparser_gram}; D_RightEpsilonHint d_right_epsilon_hints_98_dparser_gram[] = {{0, 114, &d_reduction_48_dparser_gram},{3, 130, &d_reduction_49_dparser_gram}}; D_Reduction * d_reductions_99_dparser_gram[] = {&d_reduction_46_dparser_gram}; unsigned char d_goto_valid_100_dparser_gram[] = { 0x0,0x0,0x0,0x0,0xb0,0x19,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0xf0,0xff,0x10,0x0,0x0}; D_Reduction * d_reductions_100_dparser_gram[] = {&d_reduction_106_dparser_gram}; D_RightEpsilonHint d_right_epsilon_hints_100_dparser_gram[] = {{0, 130, &d_reduction_49_dparser_gram},{2, 161, &d_reduction_100_dparser_gram}}; unsigned char d_goto_valid_101_dparser_gram[] = { 0x0,0x0,0x0,0x80,0x0,0x0,0x88,0xfb,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x14,0x70,0xf}; unsigned char d_goto_valid_102_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_102_dparser_gram[] = {&d_reduction_74_dparser_gram}; unsigned char d_goto_valid_103_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_103_dparser_gram[] = {&d_reduction_115_dparser_gram}; D_Reduction * d_reductions_104_dparser_gram[] = {&d_reduction_133_dparser_gram}; D_Reduction * d_reductions_105_dparser_gram[] = {&d_reduction_57_dparser_gram}; unsigned char d_goto_valid_106_dparser_gram[] = { 0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_106_dparser_gram[] = {&d_reduction_56_dparser_gram,&d_reduction_71_dparser_gram}; D_RightEpsilonHint d_right_epsilon_hints_106_dparser_gram[] = {{0, 138, &d_reduction_54_dparser_gram}}; unsigned char d_goto_valid_107_dparser_gram[] = { 0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_107_dparser_gram[] = {&d_reduction_61_dparser_gram}; D_RightEpsilonHint d_right_epsilon_hints_107_dparser_gram[] = {{0, 139, &d_reduction_59_dparser_gram}}; D_Reduction * d_reductions_108_dparser_gram[] = {&d_reduction_73_dparser_gram}; D_Reduction * d_reductions_109_dparser_gram[] = {&d_reduction_72_dparser_gram}; D_Reduction * d_reductions_110_dparser_gram[] = {&d_reduction_63_dparser_gram}; D_Reduction * d_reductions_111_dparser_gram[] = {&d_reduction_64_dparser_gram}; D_Reduction * d_reductions_112_dparser_gram[] = {&d_reduction_65_dparser_gram}; D_Reduction * d_reductions_113_dparser_gram[] = {&d_reduction_66_dparser_gram}; D_Reduction * d_reductions_114_dparser_gram[] = {&d_reduction_48_dparser_gram}; D_Reduction * d_reductions_115_dparser_gram[] = {&d_reduction_87_dparser_gram}; D_Reduction * d_reductions_116_dparser_gram[] = {&d_reduction_88_dparser_gram}; D_Reduction * d_reductions_117_dparser_gram[] = {&d_reduction_89_dparser_gram}; D_Reduction * d_reductions_118_dparser_gram[] = {&d_reduction_90_dparser_gram}; D_Reduction * d_reductions_119_dparser_gram[] = {&d_reduction_91_dparser_gram}; D_Reduction * d_reductions_120_dparser_gram[] = {&d_reduction_92_dparser_gram}; D_Reduction * d_reductions_121_dparser_gram[] = {&d_reduction_93_dparser_gram}; D_Reduction * d_reductions_122_dparser_gram[] = {&d_reduction_94_dparser_gram}; D_Reduction * d_reductions_123_dparser_gram[] = {&d_reduction_95_dparser_gram}; D_Reduction * d_reductions_124_dparser_gram[] = {&d_reduction_96_dparser_gram}; D_Reduction * d_reductions_125_dparser_gram[] = {&d_reduction_98_dparser_gram}; unsigned char d_goto_valid_126_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe}; D_Reduction * d_reductions_127_dparser_gram[] = {&d_reduction_50_dparser_gram}; unsigned char d_goto_valid_128_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x40,0x0,0x0,0xf0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe}; D_Reduction * d_reductions_129_dparser_gram[] = {&d_reduction_86_dparser_gram}; D_Reduction * d_reductions_130_dparser_gram[] = {&d_reduction_49_dparser_gram}; unsigned char d_goto_valid_131_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0xa4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0}; D_Reduction * d_reductions_131_dparser_gram[] = {&d_reduction_104_dparser_gram}; D_RightEpsilonHint d_right_epsilon_hints_131_dparser_gram[] = {{1, 161, &d_reduction_100_dparser_gram}}; D_Reduction * d_reductions_132_dparser_gram[] = {&d_reduction_105_dparser_gram}; D_Reduction * d_reductions_133_dparser_gram[] = {&d_reduction_107_dparser_gram}; unsigned char d_goto_valid_134_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x88,0xfb,0x10,0x0,0x0,0x0,0x2,0x0,0x0,0x14,0x70,0xf}; D_Reduction * d_reductions_135_dparser_gram[] = {&d_reduction_70_dparser_gram}; unsigned char d_goto_valid_136_dparser_gram[] = { 0x0,0x0,0x24,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_136_dparser_gram[] = {&d_reduction_62_dparser_gram}; D_RightEpsilonHint d_right_epsilon_hints_136_dparser_gram[] = {{1, 93, &d_reduction_45_dparser_gram},{3, 130, &d_reduction_49_dparser_gram}}; unsigned char d_goto_valid_137_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x88,0xfb,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x34,0x70,0xf}; unsigned char d_goto_valid_138_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf8,0x3,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_138_dparser_gram[] = {&d_reduction_54_dparser_gram}; unsigned char d_goto_valid_139_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf8,0x3,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_139_dparser_gram[] = {&d_reduction_59_dparser_gram}; unsigned char d_goto_valid_140_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_141_dparser_gram[] = {&d_reduction_85_dparser_gram}; D_Reduction * d_reductions_142_dparser_gram[] = {&d_reduction_97_dparser_gram}; unsigned char d_goto_valid_143_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_143_dparser_gram[] = {&d_reduction_102_dparser_gram}; D_RightEpsilonHint d_right_epsilon_hints_143_dparser_gram[] = {{0, 161, &d_reduction_100_dparser_gram}}; D_Reduction * d_reductions_144_dparser_gram[] = {&d_reduction_103_dparser_gram}; D_Reduction * d_reductions_145_dparser_gram[] = {&d_reduction_108_dparser_gram}; D_Reduction * d_reductions_146_dparser_gram[] = {&d_reduction_67_dparser_gram}; D_Reduction * d_reductions_147_dparser_gram[] = {&d_reduction_69_dparser_gram}; unsigned char d_goto_valid_148_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_149_dparser_gram[] = {&d_reduction_113_dparser_gram}; D_Reduction * d_reductions_150_dparser_gram[] = {&d_reduction_114_dparser_gram}; unsigned char d_goto_valid_151_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe}; unsigned char d_goto_valid_152_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x0}; D_Reduction * d_reductions_153_dparser_gram[] = {&d_reduction_77_dparser_gram}; D_Reduction * d_reductions_154_dparser_gram[] = {&d_reduction_78_dparser_gram}; D_Reduction * d_reductions_155_dparser_gram[] = {&d_reduction_79_dparser_gram}; D_Reduction * d_reductions_156_dparser_gram[] = {&d_reduction_80_dparser_gram}; unsigned char d_goto_valid_157_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe}; D_Reduction * d_reductions_158_dparser_gram[] = {&d_reduction_55_dparser_gram}; D_Reduction * d_reductions_159_dparser_gram[] = {&d_reduction_60_dparser_gram}; D_Reduction * d_reductions_160_dparser_gram[] = {&d_reduction_99_dparser_gram}; unsigned char d_goto_valid_161_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1}; D_Reduction * d_reductions_161_dparser_gram[] = {&d_reduction_100_dparser_gram}; D_Reduction * d_reductions_162_dparser_gram[] = {&d_reduction_68_dparser_gram}; D_Reduction * d_reductions_163_dparser_gram[] = {&d_reduction_75_dparser_gram}; D_Reduction * d_reductions_164_dparser_gram[] = {&d_reduction_76_dparser_gram}; D_Reduction * d_reductions_165_dparser_gram[] = {&d_reduction_83_dparser_gram}; D_Reduction * d_reductions_166_dparser_gram[] = {&d_reduction_83_dparser_gram}; unsigned char d_goto_valid_167_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0}; D_Reduction * d_reductions_167_dparser_gram[] = {&d_reduction_81_dparser_gram}; D_Reduction * d_reductions_168_dparser_gram[] = {&d_reduction_101_dparser_gram}; unsigned char d_goto_valid_169_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0}; unsigned char d_goto_valid_170_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe}; unsigned char d_goto_valid_171_dparser_gram[] = { 0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0}; D_Reduction * d_reductions_172_dparser_gram[] = {&d_reduction_82_dparser_gram}; D_Reduction * d_reductions_173_dparser_gram[] = {&d_reduction_109_dparser_gram}; unsigned short d_gotos_dparser_gram[576] = { 2,3,14,15,16,23,24,52,55,56,59,62,63,17,53,18, 19,64,67,79,82,69,80,80,91,51,33,90,93,94,81,81, 95,96,98,97,89,101,137,115,100,138,139,140,161,149,20,81, 80,162,163,171,144,172,0,145,81,146,21,174,54,0,0,4, 5,0,6,54,7,34,8,169,9,35,36,37,68,38,39,40, 41,42,22,57,170,13,0,58,10,0,0,0,11,43,44,45, 46,47,48,49,50,61,75,76,13,35,36,37,0,38,39,40, 41,42,99,25,60,0,0,66,0,12,0,35,36,37,0,38, 39,40,41,42,12,0,12,13,65,13,0,0,26,0,27,0, 13,0,0,25,0,0,28,29,22,0,13,30,31,32,0,0, 0,13,0,0,0,25,0,70,71,72,73,74,26,0,27,92, 76,165,0,0,159,0,28,29,22,0,13,30,31,32,26,0, 27,0,0,0,0,0,166,167,28,29,22,0,13,30,31,32, 78,0,0,0,35,36,37,0,38,39,40,41,42,0,0,0, 0,77,84,0,0,0,35,36,37,0,38,39,40,41,42,0, 70,71,72,73,74,152,153,154,155,156,157,158,86,0,25,0, 35,36,37,0,38,39,40,41,42,141,40,41,42,85,0,0, 25,83,0,29,22,0,0,26,0,27,0,0,0,0,0,0, 0,28,29,22,0,13,30,31,32,26,25,27,106,0,0,107, 0,108,0,28,29,22,0,13,30,31,32,0,0,0,0,0, 109,0,110,26,0,27,0,0,0,111,112,113,114,28,29,22, 0,13,30,31,32,88,30,31,32,35,36,37,0,38,39,40, 41,42,135,0,0,0,128,129,0,130,131,0,0,132,133,142, 102,0,103,134,0,0,136,0,0,0,35,36,37,0,38,39, 40,41,42,25,0,143,40,41,42,0,0,12,0,104,0,0, 0,164,40,41,42,0,29,22,105,13,0,0,26,0,27,87, 0,0,0,0,25,0,28,29,22,0,13,30,31,32,116,117, 118,119,120,121,122,123,124,125,126,127,0,0,0,26,104,27, 160,168,40,41,42,0,0,28,29,22,0,13,30,31,32,0, 0,148,30,31,32,35,36,37,0,38,39,40,41,42,30,31, 32,0,147,151,0,0,0,35,36,37,0,38,39,40,41,42, 173,40,41,42,0,0,0,0,0,0,0,0,0,0,0,25, 0,152,153,154,155,156,157,158,0,0,0,0,0,0,30,31, 32,25,0,0,0,0,0,0,26,0,27,0,0,0,0,0, 0,0,28,29,22,0,13,30,31,32,26,0,27,150,0,0, 0,0,0,0,28,29,22,0,13,30,31,32,0,30,31,32 }; D_ErrorRecoveryHint d_error_recovery_hints_2_dparser_gram[] = { {0, 5, "%>"}, {0, 5, "}"}, {0, 14, ";"}}; D_ErrorRecoveryHint d_error_recovery_hints_4_dparser_gram[] = {{1, 5, "%>"}}; D_ErrorRecoveryHint d_error_recovery_hints_5_dparser_gram[] = { {0, 5, "}"}, {0, 51, ")"}, {0, 51, "]"}}; D_ErrorRecoveryHint d_error_recovery_hints_6_dparser_gram[] = {{1, 5, "}"}}; D_ErrorRecoveryHint d_error_recovery_hints_11_dparser_gram[] = {{1, 47, "}"}}; D_ErrorRecoveryHint d_error_recovery_hints_17_dparser_gram[] = {{1, 14, ";"}}; D_ErrorRecoveryHint d_error_recovery_hints_23_dparser_gram[] = { {0, 51, ")"}, {0, 51, "]"}, {0, 51, "}"}, {2, 5, "%>"}}; D_ErrorRecoveryHint d_error_recovery_hints_24_dparser_gram[] = {{1, 51, ")"}}; D_ErrorRecoveryHint d_error_recovery_hints_25_dparser_gram[] = {{1, 51, "}"}}; D_ErrorRecoveryHint d_error_recovery_hints_26_dparser_gram[] = {{1, 51, "]"}}; D_ErrorRecoveryHint d_error_recovery_hints_50_dparser_gram[] = {{2, 5, "}"}}; D_ErrorRecoveryHint d_error_recovery_hints_55_dparser_gram[] = { {0, 47, "}"}, {0, 51, ")"}, {0, 51, "]"}}; D_ErrorRecoveryHint d_error_recovery_hints_56_dparser_gram[] = {{2, 14, ";"}}; D_ErrorRecoveryHint d_error_recovery_hints_59_dparser_gram[] = {{3, 5, "%>"}}; D_ErrorRecoveryHint d_error_recovery_hints_61_dparser_gram[] = { {0, 51, ")"}, {0, 51, "]"}, {0, 51, "}"}}; D_ErrorRecoveryHint d_error_recovery_hints_64_dparser_gram[] = {{3, 5, "}"}}; D_ErrorRecoveryHint d_error_recovery_hints_76_dparser_gram[] = {{3, 47, "}"}}; D_ErrorRecoveryHint d_error_recovery_hints_78_dparser_gram[] = {{3, 14, ";"}}; D_ErrorRecoveryHint d_error_recovery_hints_82_dparser_gram[] = {{3, 51, ")"}}; D_ErrorRecoveryHint d_error_recovery_hints_84_dparser_gram[] = {{3, 51, "}"}}; D_ErrorRecoveryHint d_error_recovery_hints_86_dparser_gram[] = {{3, 51, "]"}}; D_ErrorRecoveryHint d_error_recovery_hints_88_dparser_gram[] = {{4, 5, "}"}}; D_ErrorRecoveryHint d_error_recovery_hints_92_dparser_gram[] = {{4, 14, ";"}}; D_ErrorRecoveryHint d_error_recovery_hints_96_dparser_gram[] = { {0, 30, "}"}, {0, 30, ")"}, {0, 49, "]"}}; D_ErrorRecoveryHint d_error_recovery_hints_100_dparser_gram[] = { {0, 39, "}"}, {0, 49, "]"}}; D_ErrorRecoveryHint d_error_recovery_hints_101_dparser_gram[] = { {0, 30, "}"}, {0, 51, ")"}, {0, 51, "]"}}; D_ErrorRecoveryHint d_error_recovery_hints_102_dparser_gram[] = {{1, 30, ")"}}; D_ErrorRecoveryHint d_error_recovery_hints_103_dparser_gram[] = {{1, 49, "]"}}; D_ErrorRecoveryHint d_error_recovery_hints_126_dparser_gram[] = {{1, 39, "}"}}; D_ErrorRecoveryHint d_error_recovery_hints_131_dparser_gram[] = {{0, 47, "}"}}; D_ErrorRecoveryHint d_error_recovery_hints_136_dparser_gram[] = {{2, 30, ")"}}; D_ErrorRecoveryHint d_error_recovery_hints_137_dparser_gram[] = { {0, 49, "]"}, {0, 51, ")"}, {0, 51, "}"}}; D_ErrorRecoveryHint d_error_recovery_hints_140_dparser_gram[] = {{2, 39, "}"}}; D_ErrorRecoveryHint d_error_recovery_hints_146_dparser_gram[] = {{3, 30, "}"}}; D_ErrorRecoveryHint d_error_recovery_hints_148_dparser_gram[] = {{3, 30, ")"}}; D_ErrorRecoveryHint d_error_recovery_hints_149_dparser_gram[] = {{3, 49, "]"}}; D_ErrorRecoveryHint d_error_recovery_hints_160_dparser_gram[] = {{3, 39, "}"}}; D_ErrorRecoveryHint d_error_recovery_hints_162_dparser_gram[] = {{4, 30, ")"}}; D_State d_states_dparser_gram[] = { {d_goto_valid_0_dparser_gram, 1, {1, d_reductions_0_dparser_gram}, {2, d_right_epsilon_hints_0_dparser_gram}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {0, NULL}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 1, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_2_dparser_gram, 1, {1, d_reductions_2_dparser_gram}, {0, NULL}, {3, d_error_recovery_hints_2_dparser_gram}, 1, NULL, (void*)d_scanner_2_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_2_dparser_gram, d_accepts_diff_2_dparser_gram, -1}, {d_goto_valid_3_dparser_gram, 52, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_3_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_3_dparser_gram, d_accepts_diff_3_dparser_gram, -1}, {d_goto_valid_4_dparser_gram, 3, {1, d_reductions_4_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_4_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_5_dparser_gram, -18, {0, NULL}, {0, NULL}, {3, d_error_recovery_hints_5_dparser_gram}, 1, NULL, (void*)d_scanner_5_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_5_dparser_gram, d_accepts_diff_5_dparser_gram, -1}, {d_goto_valid_6_dparser_gram, -13, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_6_dparser_gram}, 1, NULL, (void*)d_scanner_6_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_6_dparser_gram, d_accepts_diff_6_dparser_gram, -1}, {d_goto_valid_7_dparser_gram, -1, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_6_dparser_gram}, 1, NULL, (void*)d_scanner_7_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_7_dparser_gram, d_accepts_diff_7_dparser_gram, -1}, {d_goto_valid_8_dparser_gram, 51, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_6_dparser_gram}, 1, NULL, (void*)d_scanner_7_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_7_dparser_gram, d_accepts_diff_7_dparser_gram, -1}, {NULL, -2147483647, {1, d_reductions_9_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_10_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_11_dparser_gram, 39, {1, d_reductions_11_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_11_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_12_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_13_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_14_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_15_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_16_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_17_dparser_gram, 5, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_17_dparser_gram}, 1, NULL, (void*)d_scanner_17_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_17_dparser_gram, d_accepts_diff_17_dparser_gram, -1}, {NULL, -2147483647, {1, d_reductions_18_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_19_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_20_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_21_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_22_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_23_dparser_gram, -50, {0, NULL}, {0, NULL}, {4, d_error_recovery_hints_23_dparser_gram}, 1, NULL, (void*)d_scanner_23_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_23_dparser_gram, d_accepts_diff_23_dparser_gram, -1}, {d_goto_valid_24_dparser_gram, 43, {1, d_reductions_24_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_24_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_25_dparser_gram, 40, {1, d_reductions_25_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_25_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_26_dparser_gram, 36, {1, d_reductions_26_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_26_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_27_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_28_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_29_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_30_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_31_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_32_dparser_gram, -68, {0, NULL}, {0, NULL}, {3, d_error_recovery_hints_5_dparser_gram}, 1, NULL, (void*)d_scanner_32_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_32_dparser_gram, d_accepts_diff_32_dparser_gram, -1}, {NULL, -2147483647, {1, d_reductions_33_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_34_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_35_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_36_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_37_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_38_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_39_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_40_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_41_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_42_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_43_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_44_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_45_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_46_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_47_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_48_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_49_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_50_dparser_gram, -11, {1, d_reductions_50_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_50_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_51_dparser_gram, -8, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_50_dparser_gram}, 1, NULL, (void*)d_scanner_51_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_51_dparser_gram, d_accepts_diff_51_dparser_gram, -1}, {NULL, -2147483647, {1, d_reductions_52_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_53_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_54_dparser_gram, -92, {1, d_reductions_54_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_50_dparser_gram}, 1, NULL, (void*)d_scanner_54_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_54_dparser_gram, d_accepts_diff_54_dparser_gram, -1}, {d_goto_valid_55_dparser_gram, -157, {0, NULL}, {0, NULL}, {3, d_error_recovery_hints_55_dparser_gram}, 1, NULL, (void*)d_scanner_32_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_32_dparser_gram, d_accepts_diff_32_dparser_gram, -1}, {d_goto_valid_56_dparser_gram, -1, {1, d_reductions_56_dparser_gram}, {2, d_right_epsilon_hints_56_dparser_gram}, {1, d_error_recovery_hints_56_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_57_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_58_dparser_gram, -2, {1, d_reductions_58_dparser_gram}, {2, d_right_epsilon_hints_58_dparser_gram}, {1, d_error_recovery_hints_56_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_59_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_59_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_60_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_61_dparser_gram, -175, {0, NULL}, {0, NULL}, {3, d_error_recovery_hints_61_dparser_gram}, 1, NULL, (void*)d_scanner_61_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_61_dparser_gram, d_accepts_diff_61_dparser_gram, -1}, {d_goto_valid_62_dparser_gram, -201, {0, NULL}, {0, NULL}, {3, d_error_recovery_hints_61_dparser_gram}, 1, NULL, (void*)d_scanner_32_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_32_dparser_gram, d_accepts_diff_32_dparser_gram, -1}, {d_goto_valid_63_dparser_gram, -290, {0, NULL}, {0, NULL}, {3, d_error_recovery_hints_61_dparser_gram}, 1, NULL, (void*)d_scanner_63_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_63_dparser_gram, d_accepts_diff_63_dparser_gram, -1}, {NULL, -2147483647, {1, d_reductions_64_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_64_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_65_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_66_dparser_gram, 32, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_64_dparser_gram}, 1, NULL, (void*)d_scanner_51_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_51_dparser_gram, d_accepts_diff_51_dparser_gram, -1}, {NULL, -2147483647, {1, d_reductions_67_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_64_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_68_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_69_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_70_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_71_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_72_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_73_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_74_dparser_gram, 44, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_64_dparser_gram}, 1, NULL, (void*)d_scanner_74_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_74_dparser_gram, d_accepts_diff_74_dparser_gram, -1}, {d_goto_valid_75_dparser_gram, -165, {1, d_reductions_75_dparser_gram}, {1, d_right_epsilon_hints_75_dparser_gram}, {0, NULL}, 1, NULL, (void*)d_scanner_54_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_54_dparser_gram, d_accepts_diff_54_dparser_gram, -1}, {NULL, -2147483647, {1, d_reductions_76_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_76_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_77_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_78_dparser_gram, 61, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_78_dparser_gram}, 1, NULL, (void*)d_scanner_78_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_dparser_gram, d_accepts_diff_78_dparser_gram, -1}, {d_goto_valid_79_dparser_gram, -10, {1, d_reductions_79_dparser_gram}, {1, d_right_epsilon_hints_79_dparser_gram}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_80_dparser_gram, -9, {2, d_reductions_80_dparser_gram}, {1, d_right_epsilon_hints_80_dparser_gram}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_81_dparser_gram, 55, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_78_dparser_gram}, 1, NULL, (void*)d_scanner_78_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_78_dparser_gram, d_accepts_diff_78_dparser_gram, -1}, {NULL, -2147483647, {1, d_reductions_82_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_82_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_83_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_84_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_84_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_85_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_86_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_86_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_87_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_88_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_88_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_89_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_90_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_88_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_91_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_92_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_92_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_93_dparser_gram, -20, {1, d_reductions_93_dparser_gram}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_93_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_93_dparser_gram, d_accepts_diff_93_dparser_gram, -1}, {d_goto_valid_94_dparser_gram, -15, {1, d_reductions_94_dparser_gram}, {1, d_right_epsilon_hints_94_dparser_gram}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_95_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_96_dparser_gram, -273, {0, NULL}, {0, NULL}, {3, d_error_recovery_hints_96_dparser_gram}, 1, NULL, (void*)d_scanner_96_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_96_dparser_gram, d_accepts_diff_96_dparser_gram, -1}, {NULL, -2147483647, {1, d_reductions_97_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_92_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_98_dparser_gram, -18, {1, d_reductions_98_dparser_gram}, {2, d_right_epsilon_hints_98_dparser_gram}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_99_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_100_dparser_gram, -322, {1, d_reductions_100_dparser_gram}, {2, d_right_epsilon_hints_100_dparser_gram}, {2, d_error_recovery_hints_100_dparser_gram}, 1, NULL, (void*)d_scanner_100_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_100_dparser_gram, d_accepts_diff_100_dparser_gram, -1}, {d_goto_valid_101_dparser_gram, -323, {0, NULL}, {0, NULL}, {3, d_error_recovery_hints_101_dparser_gram}, 1, NULL, (void*)d_scanner_5_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_5_dparser_gram, d_accepts_diff_5_dparser_gram, -1}, {d_goto_valid_102_dparser_gram, -5, {1, d_reductions_102_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_102_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_103_dparser_gram, 9, {1, d_reductions_103_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_103_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_104_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_105_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_106_dparser_gram, -17, {2, d_reductions_106_dparser_gram}, {1, d_right_epsilon_hints_106_dparser_gram}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_107_dparser_gram, -15, {1, d_reductions_107_dparser_gram}, {1, d_right_epsilon_hints_107_dparser_gram}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_108_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_109_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_110_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_111_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_112_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_113_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_114_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_115_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_116_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_117_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_118_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_119_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_120_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_121_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_122_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_123_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_124_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_125_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_126_dparser_gram, -205, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_126_dparser_gram}, 1, NULL, (void*)d_scanner_126_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_126_dparser_gram, d_accepts_diff_126_dparser_gram, -1}, {NULL, -2147483647, {1, d_reductions_127_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_128_dparser_gram, -329, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_126_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_126_dparser_gram, d_accepts_diff_126_dparser_gram, -1}, {NULL, -2147483647, {1, d_reductions_129_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_130_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_131_dparser_gram, -10, {1, d_reductions_131_dparser_gram}, {1, d_right_epsilon_hints_131_dparser_gram}, {1, d_error_recovery_hints_131_dparser_gram}, 1, NULL, (void*)d_scanner_131_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_131_dparser_gram, d_accepts_diff_131_dparser_gram, -1}, {NULL, -2147483647, {1, d_reductions_132_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_133_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_134_dparser_gram, -414, {0, NULL}, {0, NULL}, {3, d_error_recovery_hints_101_dparser_gram}, 1, NULL, (void*)d_scanner_32_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_32_dparser_gram, d_accepts_diff_32_dparser_gram, -1}, {NULL, -2147483647, {1, d_reductions_135_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_136_dparser_gram, -27, {1, d_reductions_136_dparser_gram}, {2, d_right_epsilon_hints_136_dparser_gram}, {1, d_error_recovery_hints_136_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_137_dparser_gram, -432, {0, NULL}, {0, NULL}, {3, d_error_recovery_hints_137_dparser_gram}, 1, NULL, (void*)d_scanner_63_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_63_dparser_gram, d_accepts_diff_63_dparser_gram, -1}, {d_goto_valid_138_dparser_gram, -146, {1, d_reductions_138_dparser_gram}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_138_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_138_dparser_gram, d_accepts_diff_138_dparser_gram, -1}, {d_goto_valid_139_dparser_gram, -414, {1, d_reductions_139_dparser_gram}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_138_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_138_dparser_gram, d_accepts_diff_138_dparser_gram, -1}, {d_goto_valid_140_dparser_gram, 24, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_140_dparser_gram}, 1, NULL, (void*)d_scanner_74_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_74_dparser_gram, d_accepts_diff_74_dparser_gram, -1}, {NULL, -2147483647, {1, d_reductions_141_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_142_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_143_dparser_gram, -8, {1, d_reductions_143_dparser_gram}, {1, d_right_epsilon_hints_143_dparser_gram}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_144_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_145_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_146_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_146_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_147_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_148_dparser_gram, 48, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_148_dparser_gram}, 1, NULL, (void*)d_scanner_148_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_148_dparser_gram, d_accepts_diff_148_dparser_gram, -1}, {NULL, -2147483647, {1, d_reductions_149_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_149_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_150_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_151_dparser_gram, -341, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_126_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_126_dparser_gram, d_accepts_diff_126_dparser_gram, -1}, {d_goto_valid_152_dparser_gram, -142, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_152_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_152_dparser_gram, d_accepts_diff_152_dparser_gram, -1}, {NULL, -2147483647, {1, d_reductions_153_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_154_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_155_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_156_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_157_dparser_gram, -389, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_126_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_126_dparser_gram, d_accepts_diff_126_dparser_gram, -1}, {NULL, -2147483647, {1, d_reductions_158_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_159_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_160_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_160_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_161_dparser_gram, -25, {1, d_reductions_161_dparser_gram}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_7_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_7_dparser_gram, d_accepts_diff_7_dparser_gram, -1}, {NULL, -2147483647, {1, d_reductions_162_dparser_gram}, {0, NULL}, {1, d_error_recovery_hints_162_dparser_gram}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_163_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_164_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_165_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_166_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_167_dparser_gram, 37, {1, d_reductions_167_dparser_gram}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_167_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_167_dparser_gram, d_accepts_diff_167_dparser_gram, -1}, {NULL, -2147483647, {1, d_reductions_168_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {d_goto_valid_169_dparser_gram, 35, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_167_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_167_dparser_gram, d_accepts_diff_167_dparser_gram, -1}, {d_goto_valid_170_dparser_gram, -436, {0, NULL}, {0, NULL}, {0, NULL}, 1, NULL, (void*)d_scanner_126_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_126_dparser_gram, d_accepts_diff_126_dparser_gram, -1}, {d_goto_valid_171_dparser_gram, -12, {0, NULL}, {0, NULL}, {1, d_error_recovery_hints_131_dparser_gram}, 1, NULL, (void*)d_scanner_131_dparser_gram, sizeof(unsigned char) , 0, D_SCAN_ALL, (void*)d_transition_131_dparser_gram, d_accepts_diff_131_dparser_gram, -1}, {NULL, -2147483647, {1, d_reductions_172_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1}, {NULL, -2147483647, {1, d_reductions_173_dparser_gram}, {0, NULL}, {0, NULL}, 0, NULL, NULL, sizeof(unsigned char) , 0, D_SCAN_ALL, NULL, NULL, -1} }; D_Symbol d_symbols_dparser_gram[] = { {D_SYMBOL_EBNF, "0 Start", 7, -1}, {D_SYMBOL_NTERM, "grammar", 7, -1}, {D_SYMBOL_INTERNAL, "grammar__2", 10, -1}, {D_SYMBOL_NTERM, "top_level_statement", 19, -1}, {D_SYMBOL_NTERM, "include_statement", 17, -1}, {D_SYMBOL_NTERM, "global_code", 11, -1}, {D_SYMBOL_INTERNAL, "global_code__9", 14, -1}, {D_SYMBOL_INTERNAL, "global_code__8", 14, -1}, {D_SYMBOL_INTERNAL, "global_code__7", 14, -1}, {D_SYMBOL_INTERNAL, "global_code__6", 14, -1}, {D_SYMBOL_NTERM, "pass_types", 10, -1}, {D_SYMBOL_NTERM, "pass_type", 9, -1}, {D_SYMBOL_NTERM, "declarationtype", 15, -1}, {D_SYMBOL_NTERM, "token_identifier", 16, -1}, {D_SYMBOL_NTERM, "production", 10, -1}, {D_SYMBOL_NTERM, "regex_production", 16, -1}, {D_SYMBOL_NTERM, "production_name", 15, -1}, {D_SYMBOL_EBNF, "production_name__17", 19, -1}, {D_SYMBOL_NTERM, "rules", 5, -1}, {D_SYMBOL_INTERNAL, "rules__20", 9, -1}, {D_SYMBOL_EBNF, "rules__19", 9, -1}, {D_SYMBOL_NTERM, "rule", 4, -1}, {D_SYMBOL_INTERNAL, "rule__28", 8, -1}, {D_SYMBOL_INTERNAL, "rule__27", 8, -1}, {D_SYMBOL_EBNF, "rule__22", 8, -1}, {D_SYMBOL_INTERNAL, "rule__22__26", 12, -1}, {D_SYMBOL_INTERNAL, "rule__22__25", 12, -1}, {D_SYMBOL_EBNF, "rule__22__23", 12, -1}, {D_SYMBOL_INTERNAL, "rule__22__23__24", 16, -1}, {D_SYMBOL_NTERM, "new_rule", 8, -1}, {D_SYMBOL_NTERM, "simple_element", 14, -1}, {D_SYMBOL_INTERNAL, "simple_element__31", 18, -1}, {D_SYMBOL_NTERM, "element", 7, -1}, {D_SYMBOL_NTERM, "new_subrule", 11, -1}, {D_SYMBOL_NTERM, "element_modifier", 16, -1}, {D_SYMBOL_EBNF, "element_modifier__35", 20, -1}, {D_SYMBOL_NTERM, "rule_modifier", 13, -1}, {D_SYMBOL_NTERM, "rule_assoc", 10, -1}, {D_SYMBOL_NTERM, "rule_priority", 13, -1}, {D_SYMBOL_NTERM, "external_action", 15, -1}, {D_SYMBOL_NTERM, "rule_code", 9, -1}, {D_SYMBOL_INTERNAL, "rule_code__43", 13, -1}, {D_SYMBOL_INTERNAL, "rule_code__42", 13, -1}, {D_SYMBOL_INTERNAL, "rule_code__41", 13, -1}, {D_SYMBOL_NTERM, "speculative_code", 16, -1}, {D_SYMBOL_NTERM, "final_code", 10, -1}, {D_SYMBOL_NTERM, "pass_code", 9, -1}, {D_SYMBOL_NTERM, "curly_code", 10, -1}, {D_SYMBOL_INTERNAL, "curly_code__48", 14, -1}, {D_SYMBOL_NTERM, "bracket_code", 12, -1}, {D_SYMBOL_INTERNAL, "bracket_code__50", 16, -1}, {D_SYMBOL_NTERM, "balanced_code", 13, -1}, {D_SYMBOL_INTERNAL, "balanced_code__54", 17, -1}, {D_SYMBOL_INTERNAL, "balanced_code__53", 17, -1}, {D_SYMBOL_INTERNAL, "balanced_code__52", 17, -1}, {D_SYMBOL_NTERM, "symbols", 7, -1}, {D_SYMBOL_NTERM, "string", 6, -1}, {D_SYMBOL_NTERM, "regex", 5, -1}, {D_SYMBOL_NTERM, "unicode_char", 12, -1}, {D_SYMBOL_NTERM, "identifier", 10, -1}, {D_SYMBOL_NTERM, "integer", 7, -1}, {D_SYMBOL_NTERM, "decimalint", 10, -1}, {D_SYMBOL_NTERM, "hexint", 6, -1}, {D_SYMBOL_NTERM, "octalint", 8, -1}, {D_SYMBOL_STRING, "include", 7}, {D_SYMBOL_STRING, "%<", 2}, {D_SYMBOL_STRING, "%>", 2}, {D_SYMBOL_STRING, "${scanner", 9}, {D_SYMBOL_STRING, "}", 1}, {D_SYMBOL_STRING, "${declare", 9}, {D_SYMBOL_STRING, "}", 1}, {D_SYMBOL_STRING, "${token", 7}, {D_SYMBOL_STRING, "}", 1}, {D_SYMBOL_STRING, "${pass", 6}, {D_SYMBOL_STRING, "}", 1}, {D_SYMBOL_STRING, "preorder", 8}, {D_SYMBOL_STRING, "postorder", 9}, {D_SYMBOL_STRING, "manual", 6}, {D_SYMBOL_STRING, "for_all", 7}, {D_SYMBOL_STRING, "for_undefined", 13}, {D_SYMBOL_STRING, "tokenize", 8}, {D_SYMBOL_STRING, "longest_match", 13}, {D_SYMBOL_STRING, "whitespace", 10}, {D_SYMBOL_STRING, "all_matches", 11}, {D_SYMBOL_STRING, "set_op_priority_from_rule", 25}, {D_SYMBOL_STRING, "all_subparsers", 14}, {D_SYMBOL_STRING, "subparser", 9}, {D_SYMBOL_STRING, "save_parse_tree", 15}, {D_SYMBOL_STRING, ":", 1}, {D_SYMBOL_STRING, ";", 1}, {D_SYMBOL_STRING, ";", 1}, {D_SYMBOL_STRING, ";", 1}, {D_SYMBOL_STRING, "::=", 3}, {D_SYMBOL_STRING, "_", 1}, {D_SYMBOL_STRING, "|", 1}, {D_SYMBOL_STRING, "${scan", 6}, {D_SYMBOL_STRING, "}", 1}, {D_SYMBOL_STRING, "(", 1}, {D_SYMBOL_STRING, ")", 1}, {D_SYMBOL_STRING, "$term", 5}, {D_SYMBOL_STRING, "$name", 5}, {D_SYMBOL_STRING, "/i", 2}, {D_SYMBOL_STRING, "?", 1}, {D_SYMBOL_STRING, "*", 1}, {D_SYMBOL_STRING, "+", 1}, {D_SYMBOL_STRING, "@", 1}, {D_SYMBOL_STRING, "@", 1}, {D_SYMBOL_STRING, ":", 1}, {D_SYMBOL_STRING, "$unary_op_right", 15}, {D_SYMBOL_STRING, "$unary_op_left", 14}, {D_SYMBOL_STRING, "$binary_op_right", 16}, {D_SYMBOL_STRING, "$binary_op_left", 15}, {D_SYMBOL_STRING, "$unary_right", 12}, {D_SYMBOL_STRING, "$unary_left", 11}, {D_SYMBOL_STRING, "$binary_right", 13}, {D_SYMBOL_STRING, "$binary_left", 12}, {D_SYMBOL_STRING, "$right", 6}, {D_SYMBOL_STRING, "$left", 5}, {D_SYMBOL_STRING, "${action}", 9}, {D_SYMBOL_STRING, "${action", 8}, {D_SYMBOL_STRING, "}", 1}, {D_SYMBOL_STRING, ":", 1}, {D_SYMBOL_STRING, "{", 1}, {D_SYMBOL_STRING, "}", 1}, {D_SYMBOL_STRING, "[", 1}, {D_SYMBOL_STRING, "]", 1}, {D_SYMBOL_STRING, "(", 1}, {D_SYMBOL_STRING, ")", 1}, {D_SYMBOL_STRING, "[", 1}, {D_SYMBOL_STRING, "]", 1}, {D_SYMBOL_STRING, "{", 1}, {D_SYMBOL_STRING, "}", 1}, {D_SYMBOL_REGEX, "[!~`@#$%^&*\\\\-_+=|:;\\\\\\\\<,>.?/]", 37}, {D_SYMBOL_REGEX, "'([^'\\\\\\\\]|\\\\\\\\[^])*'", 29}, {D_SYMBOL_REGEX, "\\\"([^\\\"\\\\\\\\]|\\\\\\\\[^])*\\\"", 38}, {D_SYMBOL_REGEX, "[uU]\\\\+[0-9a-fA-F]+", 21}, {D_SYMBOL_REGEX, "[a-zA-Z_][a-zA-Z_0-9]*", 22}, {D_SYMBOL_REGEX, "-?[1-9][0-9]*[uUlL]?", 20}, {D_SYMBOL_REGEX, "-?(0x|0X)[0-9a-fA-F]+[uUlL]?", 28}, {D_SYMBOL_REGEX, "-?0[0-7]*[uUlL]?", 16}, }; D_ParserTables parser_tables_dparser_gram = { 174, d_states_dparser_gram, d_gotos_dparser_gram, 0, 140, d_symbols_dparser_gram, NULL, 0, NULL, 0}; mcrl2-201210.1/3rd-party/dparser/dparse.h000775 001751 001751 00000005150 12042421220 021034 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ #ifndef _dparse_H_ #define _dparse_H_ #include #if defined(__cplusplus) extern "C" { #endif #include "dparse_tables.h" #include "dsymtab.h" struct D_Parser; struct D_ParserTables; struct D_Scope; struct D_ParseNode; typedef void *d_voidp; #ifndef D_ParseNode_User #define D_ParseNode_User d_voidp #endif #ifndef D_ParseNode_Globals #define D_ParseNode_Globals void #endif typedef void (*D_SyntaxErrorFn)(struct D_Parser *); typedef struct D_ParseNode *(*D_AmbiguityFn)(struct D_Parser *, int n, struct D_ParseNode **v); typedef void (*D_FreeNodeFn)(struct D_ParseNode *d); typedef struct D_Parser { D_ParseNode_Globals *initial_globals; /* global values */ D_WhiteSpaceFn initial_white_space_fn; struct D_Scope *initial_scope; D_SyntaxErrorFn syntax_error_fn; D_AmbiguityFn ambiguity_fn; D_FreeNodeFn free_node_fn; d_loc_t loc; /* initial location, set on error */ int start_state; /* do not move or change without fixing copy_user_configurables() */ /* user configurables */ int sizeof_user_parse_node; int save_parse_tree; int dont_compare_stacks; int dont_fixup_internal_productions; int fixup_EBNF_productions; int dont_merge_epsilon_trees; int dont_use_height_for_disambiguation; int dont_use_greediness_for_disambiguation; int commit_actions_interval; /* 0 is immediate */ int error_recovery; int partial_parses; /* parse results */ int syntax_errors; /* do not move or change without fixing copy_user_configurables() */ } D_Parser; typedef struct D_ParseNode { int symbol; d_loc_t start_loc; char *end; char *end_skip; struct D_Scope *scope; D_WhiteSpaceFn white_space; D_ParseNode_Globals *globals; D_ParseNode_User user; } D_ParseNode; D_Parser *new_D_Parser(struct D_ParserTables *t, int sizeof_ParseNode_User); void free_D_Parser(D_Parser *p); D_ParseNode *dparse(D_Parser *p, char *buf, int buf_len); void free_D_ParseNode(D_Parser *p, D_ParseNode *pn); void free_D_ParseTreeBelow(D_Parser *p, D_ParseNode *pn); int d_get_number_of_children(D_ParseNode *pn); D_ParseNode *d_get_child(D_ParseNode *pn, int child); D_ParseNode *d_find_in_tree(D_ParseNode *pn, int symbol); char *d_ws_before(D_Parser *p, D_ParseNode *pn); /* points BEFORE leading ws */ char *d_ws_after(D_Parser *p, D_ParseNode *pn); /* points AFTER trailing ws */ void d_pass(D_Parser *p, D_ParseNode *pn, int pass_number); int resolve_amb_greedy(D_Parser *dp, int n, D_ParseNode **v); char *d_dup_pathname_str(const char *str); #if defined(__cplusplus) } #endif #endif mcrl2-201210.1/3rd-party/dparser/COPYRIGHT000775 001751 001751 00000002572 12042421220 020705 0ustar00jenkinsjenkins000000 000000 Copyright (c) 1994-2010 John Bradley Plevyak, All Rights Reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. mcrl2-201210.1/3rd-party/dparser/gram.h000775 001751 001751 00000017325 12042421220 020513 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ #ifndef _gram_H_ #define _gram_H_ #define EOF_SENTINAL "\377" #define NO_PROD 0xFFFFFFFF struct Production; struct Rule; struct Elem; struct Term; struct State; struct ScanState; struct ScanStateTransition; struct D_ParserTables; typedef struct Elem Item; typedef struct Code { char *code; int line; } Code; typedef struct Goto { struct Elem *elem; struct State *state; } Goto; typedef Vec(Goto *) VecGoto; typedef enum ActionKind { ACTION_ACCEPT, ACTION_SHIFT, ACTION_REDUCE, ACTION_SHIFT_TRAILING } ActionKind; typedef struct Action { ActionKind kind; struct Term *term; struct Rule *rule; struct State *state; uint index; char *temp_string; } Action; typedef Vec(Action *) VecAction; typedef struct Hint { uint depth; struct State *state; struct Rule *rule; } Hint; typedef Vec(Hint *) VecHint; typedef Vec(struct ScanStateTransition*) VecScanStateTransition; typedef Vec(struct ScanState *) VecScanState; typedef struct Scanner { VecScanState states; VecScanStateTransition transitions; } Scanner; typedef struct State { uint index; uint64 hash; Vec(Item*) items; Vec(Item*) items_hash; VecGoto gotos; VecAction shift_actions; VecAction reduce_actions; VecHint right_epsilon_hints; VecHint error_recovery_hints; Scanner scanner; uint accept:1; uint scanner_code:1; uint goto_on_token:1; uint scan_kind:3; uint trailing_context:1; uint8 *goto_valid; int goto_table_offset; struct State *same_shifts; struct State *reduces_to; struct Rule *reduces_with; struct Rule *reduces_to_then_with; } State; #define ASSOC_LEFT 0x0001 #define ASSOC_RIGHT 0x0002 #define ASSOC_NARY 0x0004 #define ASSOC_UNARY 0x0008 #define ASSOC_BINARY 0x0010 typedef enum AssocKind { ASSOC_NONE = 0, ASSOC_NARY_LEFT = (ASSOC_NARY|ASSOC_LEFT), ASSOC_NARY_RIGHT = (ASSOC_NARY|ASSOC_RIGHT), ASSOC_UNARY_LEFT = (ASSOC_UNARY|ASSOC_LEFT), ASSOC_UNARY_RIGHT = (ASSOC_UNARY|ASSOC_RIGHT), ASSOC_BINARY_LEFT = (ASSOC_BINARY|ASSOC_LEFT), ASSOC_BINARY_RIGHT = (ASSOC_BINARY|ASSOC_RIGHT), ASSOC_NO = 0x0020 } AssocKind; #define IS_RIGHT_ASSOC(_x) ((_x) & ASSOC_RIGHT) #define IS_LEFT_ASSOC(_x) ((_x) & ASSOC_LEFT) #define IS_NARY_ASSOC(_x) ((_x) & ASSOC_NARY) #define IS_BINARY_ASSOC(_x) ((_x) & ASSOC_BINARY) #define IS_UNARY_ASSOC(_x) ((_x) & ASSOC_UNARY) #define IS_UNARY_BINARY_ASSOC(_x) (IS_BINARY_ASSOC(_x) || IS_UNARY_ASSOC(_x)) #define IS_BINARY_NARY_ASSOC(_x) (IS_BINARY_ASSOC(_x) || IS_NARY_ASSOC(_x)) /* not valid for NARY */ #define IS_EXPECT_RIGHT_ASSOC(_x) ((_x) && (_x) != ASSOC_UNARY_LEFT) #define IS_EXPECT_LEFT_ASSOC(_x) ((_x) && _x != ASSOC_UNARY_RIGHT) typedef struct Rule { uint index; struct Production *prod; int op_priority; AssocKind op_assoc; int rule_priority; AssocKind rule_assoc; Vec(struct Elem*) elems; struct Elem *end; Code speculative_code; Code final_code; Vec(Code*) pass_code; int action_index; struct Rule *same_reduction; } Rule; typedef enum TermKind { TERM_STRING, TERM_REGEX, TERM_CODE, TERM_TOKEN } TermKind; typedef struct Term { TermKind kind; uint index; int term_priority; char *term_name; AssocKind op_assoc; int op_priority; char *string; int string_len; uint scan_kind:3; uint ignore_case:1; uint trailing_context:1; struct Production *regex_production; } Term; typedef Vec(Term *) TermVec; typedef enum DeclarationKind { DECLARE_TOKENIZE, DECLARE_LONGEST_MATCH, DECLARE_ALL_MATCHES, DECLARE_SET_OP_PRIORITY, DECLARE_STATES_FOR_ALL_NTERMS, DECLARE_STATE_FOR, DECLARE_WHITESPACE, DECLARE_SAVE_PARSE_TREE, DECLARE_NUM } DeclarationKind; typedef struct Declaration { struct Elem * elem; uint kind; uint index; } Declaration; typedef enum InternalKind { INTERNAL_NOT, INTERNAL_HIDDEN, INTERNAL_CONDITIONAL, INTERNAL_STAR, INTERNAL_PLUS } InternalKind; typedef struct Production { char *name; uint name_len; Vec(Rule *) rules; uint index; uint regex:1; uint in_regex:1; uint internal:3; /* production used for EBNF */ uint live:1; Rule *nullable; /* shortest rule for epsilon reduction */ struct Production *declaration_group[DECLARE_NUM]; struct Declaration *last_declaration[DECLARE_NUM]; State *state; /* state for independent parsing of this productions*/ struct Elem *elem; /* base elem for the item set of the above state */ struct Term *regex_term; /* regex production terminal */ char *regex_term_name; struct Production *next; } Production; typedef enum ElemKind { ELEM_NTERM, ELEM_TERM, ELEM_UNRESOLVED, ELEM_END } ElemKind; typedef struct Elem { ElemKind kind; uint index; Rule *rule; union { Production *nterm; Term *term; void *term_or_nterm; struct Unresolved { char *string; uint len; } unresolved; } e; } Elem; typedef struct Grammar { char *pathname; Vec(Production *) productions; Vec(Term *) terminals; Vec(State *) states; Vec(Action *) actions; Code scanner; Code *code; int ncode; Vec(Declaration *) declarations; Vec(D_Pass *) passes; Vec(char *) all_pathnames; char *default_white_space; /* grammar construction options */ int set_op_priority_from_rule; int right_recursive_BNF; int states_for_whitespace; int states_for_all_nterms; int tokenizer; int longest_match; int save_parse_tree; /* grammar writing options */ char grammar_ident[256]; int scanner_blocks; int scanner_block_size; int write_line_directives; int write_header; int token_type; int write_cpp; char write_extension[256]; /* temporary variables for grammar construction */ struct Production * p; struct Rule * r; struct Elem * e; int action_index; int action_count; int pass_index; int rule_index; int write_line; char *write_pathname; } Grammar; /* automatically add %op_XXX to rightmost token of %XXX rule, default off */ Grammar *new_D_Grammar(char *pathname); void free_D_Grammar(Grammar *g); int build_grammar(Grammar *g); int parse_grammar(Grammar *g, char *pathname, char *str); void print_grammar(Grammar *g); void print_rdebug_grammar(Grammar *g, char *pathname); void print_states(Grammar *g); void print_rule(Rule *r); void print_term(Term *t); Production *lookup_production(Grammar *g, char *name, int len); /* for creating grammars */ #define last_elem(_r) ((_r)->elems.v[(_r)->elems.n-1]) Rule *new_rule(Grammar *g, Production *p); Elem *new_elem_nterm(Production *p, Rule *r); void new_declaration(Grammar *g, Elem *e, uint kind); Production *new_production(Grammar *g, char *name); Elem *new_string(Grammar *g, char *s, char *e, Rule *r); Elem *new_utf8_char(Grammar *g, char *s, char *e, Rule *r); Elem *new_ident(char *s, char *e, Rule *r); void new_token(Grammar *g, char *s, char *e); Elem *new_code(Grammar *g, char *s, char *e, Rule *r); void add_global_code(Grammar *g, char *start, char *end, int line); Production *new_internal_production(Grammar *g, Production *p); Elem * dup_elem(Elem *e, Rule *r); void add_declaration(Grammar *g, char *start, char *end, uint kind, uint line); void add_pass(Grammar *g, char *start, char *end, uint kind, uint line); void add_pass_code(Grammar *g, Rule *r, char *pass_start, char *pass_end, char *code_start, char *code_end, uint line, uint pass_line); D_Pass *find_pass(Grammar *g, char *start, char *end); void conditional_EBNF(Grammar *g); /* applied to g->e,g->r,g->p */ void star_EBNF(Grammar *g); /* ditto */ void plus_EBNF(Grammar *g); /* ditto */ void rep_EBNF(Grammar *g, int minimum, int maximum); void initialize_productions(Grammar *g); void finalize_productions(Grammar *g); int state_for_declaration(Grammar *g, int iproduction); #endif mcrl2-201210.1/3rd-party/dparser/version.c000775 001751 001751 00000000367 12042421220 021243 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ #include "d.h" void d_version(char *v) { v += sprintf(v, "%d.%d", D_MAJOR_VERSION, D_MINOR_VERSION); if (strcmp("",D_BUILD_VERSION)) v += sprintf(v, ".%s", D_BUILD_VERSION); } mcrl2-201210.1/3rd-party/dparser/scan.h000775 001751 001751 00000000441 12042421220 020500 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ #ifndef _scan_H_ #define _scan_H_ #include "d.h" typedef struct ShiftResult { struct SNode *snode; D_Shift *shift; d_loc_t loc; } ShiftResult; int scan_buffer(d_loc_t *loc, D_State *st, ShiftResult *result); #endif mcrl2-201210.1/3rd-party/dparser/mkdparse.c000775 001751 001751 00000001346 12042421220 021362 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ #include "gramgram.h" #include "d.h" #include "mkdparse.h" static void mkdparse_internal(Grammar *g, char *grammar_pathname, char *str) { if (!grammar_pathname) grammar_pathname = "-"; if (parse_grammar(g, grammar_pathname, str) < 0) d_fail("unable to parse grammar '%s'", grammar_pathname); if (g->productions.n < 2) d_fail("no productions in grammar '%s'", grammar_pathname); if (build_grammar(g) < 0) d_fail("unable to load grammar '%s'", grammar_pathname); } void mkdparse(Grammar *g, char *grammar_pathname) { mkdparse_internal(g, grammar_pathname, 0); } void mkdparse_from_string(Grammar *g, char *str) { mkdparse_internal(g, 0, str); } mcrl2-201210.1/3rd-party/dparser/lex.c000775 001751 001751 00000032330 12042421220 020341 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ #include "d.h" typedef struct NFAState { uint index; Vec(struct NFAState*) chars[256]; Vec(struct NFAState*) epsilon; Vec(Action*) accepts; Vec(Action*) live; } NFAState; typedef struct DFAState { Vec(struct NFAState*) states; struct DFAState *chars[256]; ScanState *scan; } DFAState; typedef Vec(DFAState *) VecDFAState; typedef Vec(NFAState *) VecNFAState; typedef struct LexState { uint nfa_index; VecNFAState allnfas; uint transitions; uint scanners; uint ignore_case; } LexState; static NFAState * new_NFAState(LexState *ls) { NFAState *n = MALLOC(sizeof(NFAState)); memset(n, 0, sizeof(NFAState)); n->index = ls->nfa_index++; vec_add(&ls->allnfas, n); return n; } static DFAState * new_DFAState() { DFAState *n = MALLOC(sizeof(DFAState)); memset(n, 0, sizeof(DFAState)); return n; } static void free_DFAState(DFAState *y) { vec_free(&y->states); FREE(y); } static void free_VecDFAState(VecDFAState *dfas) { int i; for (i = 0; i < dfas->n; i++) free_DFAState(dfas->v[i]); vec_free(dfas); } static void free_NFAState(NFAState *y) { int i; for (i = 0; i < 256; i++) vec_free(&y->chars[i]); vec_free(&y->epsilon); vec_free(&y->accepts); FREE(y); } static void free_VecNFAState(VecNFAState *nfas) { int i; for (i = 0; i < nfas->n; i++) free_NFAState(nfas->v[i]); vec_free(nfas); } static ScanState * new_ScanState() { ScanState *n = MALLOC(sizeof(ScanState)); memset(n, 0, sizeof(ScanState)); return n; } static int nfacmp(const void *ai, const void *aj) { uint32 i = (*(NFAState**)ai)->index; uint32 j = (*(NFAState**)aj)->index; return (i > j) ? 1 : ((i < j) ? -1 : 0); } static void nfa_closure(DFAState *x) { int i, j, k; for (i = 0; i < x->states.n; i++) for (j = 0; j < x->states.v[i]->epsilon.n; j++) { NFAState *s; for (k = 0; k < x->states.n; k++) if (x->states.v[i]->epsilon.v[j] == x->states.v[k]) goto Lbreak; s = x->states.v[i]; vec_add(&x->states, s->epsilon.v[j]); Lbreak:; } qsort(x->states.v, x->states.n, sizeof(x->states.v[0]), nfacmp); } static int eq_dfa_state(DFAState *x, DFAState *y) { int i; if (x->states.n != y->states.n) return 0; for (i = 0; i < x->states.n; i++) if (x->states.v[i] != y->states.v[i]) return 0; return 1; } static void dfa_to_scanner(VecDFAState *alldfas, VecScanState *scanner) { int i, j, k, highest, p; vec_clear(scanner); for (i = 0; i < alldfas->n; i++) { alldfas->v[i]->scan = new_ScanState(); alldfas->v[i]->scan->index = i; vec_add(scanner, alldfas->v[i]->scan); } for (i = 0; i < alldfas->n; i++) { for (j = 0; j < 256; j++) if (alldfas->v[i]->chars[j]) alldfas->v[i]->scan->chars[j] = alldfas->v[i]->chars[j]->scan; highest = INT_MIN; for (j = 0; j < alldfas->v[i]->states.n; j++) for (k = 0; k < alldfas->v[i]->states.v[j]->accepts.n; k++) { p = alldfas->v[i]->states.v[j]->accepts.v[k]->term->term_priority; if (highest < p) highest = p; } for (j = 0; j < alldfas->v[i]->states.n; j++) for (k = 0; k < alldfas->v[i]->states.v[j]->accepts.n; k++) { p = alldfas->v[i]->states.v[j]->accepts.v[k]->term->term_priority; if (p == highest) vec_add(&alldfas->v[i]->scan->accepts, alldfas->v[i]->states.v[j]->accepts.v[k]); } } } static void nfa_to_scanner(NFAState *n, Scanner *s) { DFAState *x = new_DFAState(), *y; VecDFAState alldfas; int i, i_alldfas, i_states, i_char; VecScanState *scanner = &s->states; memset(&alldfas, 0, sizeof(alldfas)); vec_add(&x->states, n); nfa_closure(x); vec_add(&alldfas, x); for (i_alldfas = 0; i_alldfas < alldfas.n; i_alldfas++) { x = alldfas.v[i_alldfas]; for (i_char = 0; i_char < 256; i_char++) { y = NULL; for (i_states = 0; i_states < x->states.n; i_states++) { for (i = 0; i < x->states.v[i_states]->chars[i_char].n; i++) { if (!y) y = new_DFAState(); set_add(&y->states, x->states.v[i_states]->chars[i_char].v[i]); } } if (y) { set_to_vec(&y->states); nfa_closure(y); for (i = 0; i < alldfas.n; i++) if (eq_dfa_state(y, alldfas.v[i])) { free_DFAState(y); y = alldfas.v[i]; goto Lnext; } vec_add(&alldfas, y); Lnext: x->chars[i_char] = y; } } } dfa_to_scanner(&alldfas, scanner); free_VecDFAState(&alldfas); } /* build a NFA for the regular expression */ static int build_regex_nfa(LexState *ls, uint8 **areg, NFAState *pp, NFAState *nn, Action *trailing) { uint8 c, pc, *reg = *areg; NFAState *p = pp, *s, *x, *n = nn; int reversed, i, has_trailing = 0; uint8 mark[256]; s = p; while ((c = *reg++)) { switch(c) { case '(': has_trailing = build_regex_nfa(ls, ®, s, (x = new_NFAState(ls)), trailing) || has_trailing; p = s; s = x; break; case ')': goto Lreturn; case '|': vec_add(&s->epsilon, nn); vec_add(&pp->epsilon, (s = new_NFAState(ls))); break; case '[': if (*reg == '^') { reg++; reversed = 1; } else reversed = 0; memset(mark, 0, sizeof(mark)); pc = UCHAR_MAX; while ((c = *reg++)) { switch(c) { case ']': goto Lsetdone; case '-': c = *reg++; if (!c) goto Lerror; if (c == '\\') c = *reg++; if (!c) goto Lerror; for (;pc <= c; pc++) mark[pc] = 1; break; case '\\': c = *reg++; /* fall through */ default: pc = c; mark[c] = 1; break; } } Lsetdone: x = new_NFAState(ls); for (i = 1; i < 256; i++) if ((!reversed && mark[i]) || (reversed && !mark[i])) vec_add(&s->chars[i], x); p = s; s = x; break; case '?': vec_add(&p->epsilon, s); break; case '*': vec_add(&p->epsilon, s); vec_add(&s->epsilon, p); break; case '+': vec_add(&s->epsilon, p); break; case '/': vec_add(&s->accepts, trailing); has_trailing = 1; break; case '\\': c = *reg++; if (!c) goto Lerror; /* fall through */ default: if (!ls->ignore_case || !isalpha(c)) vec_add(&s->chars[c], (x = new_NFAState(ls))); else { vec_add(&s->chars[tolower(c)], (x = new_NFAState(ls))); vec_add(&s->chars[toupper(c)], x); } p = s; s = x; break; } } Lreturn: vec_add(&s->epsilon, n); *areg = reg; return has_trailing; Lerror: d_fail("bad (part of) regex: %s\n", *areg); return has_trailing; } static void action_diff(VecAction *a, VecAction *b, VecAction *c) { int bb = 0, cc = 0; while (1) { if (bb >= b->n) break; Lagainc: if (cc >= c->n) { while (bb < b->n) vec_add(a, b->v[bb++]); break; } Lagainb: if (b->v[bb]->index == c->v[cc]->index) { bb++; cc++; continue; } if (b->v[bb]->index < c->v[cc]->index) { vec_add(a, b->v[bb++]); if (bb >= b->n) break; goto Lagainb; } cc++; goto Lagainc; } } static void action_intersect(VecAction *a, VecAction *b, VecAction *c) { int bb = 0, cc = 0; while (1) { if (bb >= b->n) break; Lagainc: if (cc >= c->n) break; Lagainb: if (b->v[bb]->index == c->v[cc]->index) { vec_add(a, b->v[bb++]); cc++; continue; } if (b->v[bb]->index < c->v[cc]->index) { bb++; if (bb >= b->n) break; goto Lagainb; } cc++; goto Lagainc; } } static void compute_liveness(Scanner *scanner) { int i, j, changed = 1; ScanState *ss, *sss; VecScanState *states = &scanner->states; /* basis */ for (i = 0; i < states->n; i++) { ss = states->v[i]; set_union(&ss->live, &ss->accepts); } while (changed) { changed = 0; for (i = 0; i < states->n; i++) { ss = states->v[i]; for (j = 0; j < 256; j++) { if ((sss = ss->chars[j])) { if (ss != sss) if (set_union(&ss->live, &sss->live)) changed = 1; } } } } for (i = 0; i < states->n; i++) { ss = states->v[i]; set_to_vec(&ss->live); sort_VecAction(&ss->live); } } static uint32 trans_hash_fn(ScanStateTransition *a, hash_fns_t *fns) { uint h = 0; int i; if (!fns->data[0]) for (i = 0; i < a->live_diff.n; i++) h += 3 * a->live_diff.v[i]->index; for (i = 0; i < a->accepts_diff.n; i++) h += 3 * a->accepts_diff.v[i]->index; return h; } static int trans_cmp_fn(ScanStateTransition *a, ScanStateTransition *b, hash_fns_t *fns) { int i; if (!fns->data[0]) if (a->live_diff.n != b->live_diff.n) return 1; if (a->accepts_diff.n != b->accepts_diff.n) return 1; if (!fns->data[0]) for (i = 0; i < a->live_diff.n; i++) if (a->live_diff.v[i] != b->live_diff.v[i]) return 1; for (i = 0; i < a->accepts_diff.n; i++) if (a->accepts_diff.v[i] != b->accepts_diff.v[i]) return 1; return 0; } static hash_fns_t trans_hash_fns = { (hash_fn_t)trans_hash_fn, (cmp_fn_t)trans_cmp_fn, { 0, 0 } }; static void build_transitions(LexState *ls, Scanner *s) { int i, j; ScanState *ss; ScanStateTransition *trans = NULL, *x; VecScanState *states = &s->states; #ifdef LIVE_DIFF_IN_TRANSITIONS trans_hash_fns.data[0] = (void*)0; #else trans_hash_fns.data[0] = (void*)1; #endif for (i = 0; i < states->n; i++) { ss = states->v[i]; for (j = 0; j < 256; j++) { if (!trans) { trans = MALLOC(sizeof(*trans)); memset(trans, 0, sizeof(*trans)); } if (ss->chars[j]) { action_diff(&trans->live_diff, &ss->live, &ss->chars[j]->live); action_intersect(&trans->accepts_diff, &ss->accepts, &trans->live_diff); } if ((x = set_add_fn(&s->transitions, trans, &trans_hash_fns)) == trans) trans = NULL; else { vec_free(&trans->live_diff); vec_free(&trans->accepts_diff); } ss->transition[j] = x; } } if (trans) FREE(trans); j = 0; set_to_vec(&s->transitions); for (i = 0; i < s->transitions.n; i++) s->transitions.v[i]->index = i; ls->transitions += s->transitions.n; } static void compute_transitions(LexState *ls, Scanner *s) { compute_liveness(s); build_transitions(ls, s); } static void build_state_scanner(Grammar *g, LexState *ls, State *s) { NFAState *n, *nn, *nnn; Action *a; uint8 *c, *reg; int j, one; one = 0; n = new_NFAState(ls); /* first strings since they can be trivially combined as a tree */ for (j = 0; j < s->shift_actions.n; j++) { a = s->shift_actions.v[j]; if (a->kind == ACTION_ACCEPT) { one = 1; if (!n->chars[0].n) vec_add(&n->chars[0], (nnn = new_NFAState(ls))); else nnn = n->chars[0].v[0]; vec_add(&nnn->accepts, a); } else if (a->kind == ACTION_SHIFT && a->term->kind == TERM_STRING) { one = 1; nn = n; if (!a->term->ignore_case) { for (c = (uint8*)a->term->string; *c; c++) { if (!nn->chars[*c].n) vec_add(&nn->chars[*c], (nnn = new_NFAState(ls))); else nnn = nn->chars[*c].v[0]; nn = nnn; } } else { /* use new states */ for (c = (uint8*)a->term->string; *c; c++) { if (isalpha(*c)) { vec_add(&nn->chars[toupper(*c)], (nnn = new_NFAState(ls))); vec_add(&nn->chars[tolower(*c)], nnn); } else vec_add(&nn->chars[*c], (nnn = new_NFAState(ls))); nn = nnn; } } vec_add(&nn->accepts, a); } } /* now regexes */ for (j = 0; j < s->shift_actions.n; j++) { a = s->shift_actions.v[j]; if (a->kind == ACTION_SHIFT && a->term->kind == TERM_REGEX) { Action *trailing_context = (Action *)MALLOC(sizeof(Action)); memcpy(trailing_context, a, sizeof(Action)); trailing_context->kind = ACTION_SHIFT_TRAILING; trailing_context->index = g->action_count++; one = 1; reg = (uint8*)a->term->string; vec_add(&n->epsilon, (nnn = new_NFAState(ls))); nn = new_NFAState(ls); ls->ignore_case = a->term->ignore_case; if (build_regex_nfa(ls, ®, nnn, nn, trailing_context)) { a->term->trailing_context = 1; s->trailing_context = 1; vec_add(&g->actions, trailing_context); } else FREE(trailing_context); vec_add(&nn->accepts, a); } } if (one) { nfa_to_scanner(n, &s->scanner); compute_transitions(ls, &s->scanner); } free_VecNFAState(&ls->allnfas); ls->scanners++; } static LexState * new_LexState() { LexState *ls = MALLOC(sizeof(LexState)); memset(ls, 0, sizeof(LexState)); vec_clear(&ls->allnfas); return ls; } void build_scanners(Grammar *g) { int i, j, k; State *s; LexState *ls = new_LexState(); /* detect identical scanners */ for (i = 0; i < g->states.n; i++) { s = g->states.v[i]; if (s->same_shifts) continue; for (j = 0; j < i; j++) { if (g->states.v[j]->same_shifts) continue; if (g->states.v[j]->shift_actions.n != s->shift_actions.n) continue; if (g->states.v[j]->scan_kind != s->scan_kind) continue; for (k = 0; k < g->states.v[j]->shift_actions.n; k++) if (s->shift_actions.v[k]->term != g->states.v[j]->shift_actions.v[k]->term) break; if (k >= g->states.v[j]->shift_actions.n) { s->same_shifts = g->states.v[j]; break; } } } /* build scanners */ for (i = 0; i < g->states.n; i++) { s = g->states.v[i]; if (s->shift_actions.n) { if (s->same_shifts) s->scanner = s->same_shifts->scanner; else build_state_scanner(g, ls, s); } } if (d_verbose_level) printf("%d scanners %d transitions\n", ls->scanners, ls->transitions); FREE(ls); } mcrl2-201210.1/3rd-party/dparser/write_tables.h000775 001751 001751 00000000435 12042421220 022243 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ int write_c_tables(Grammar *g); int write_binary_tables(Grammar *g); int write_binary_tables_to_file(Grammar *g, FILE *fp); int write_binary_tables_to_string(Grammar *g, unsigned char **str, unsigned int *str_len); mcrl2-201210.1/3rd-party/dparser/parse.c000775 001751 001751 00000172023 12042421220 020667 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2008 John Plevyak, All Rights Reserved */ #include "d.h" /* tunables */ #define DEFAULT_COMMIT_ACTIONS_INTERVAL 100 #define PNODE_HASH_INITIAL_SIZE_INDEX 10 #define SNODE_HASH_INITIAL_SIZE_INDEX 8 #define ERROR_RECOVERY_QUEUE_SIZE 10000 #define LATEST(_p, _pn) do { \ while ((_pn)->latest != (_pn)->latest->latest) { \ PNode *t = (_pn)->latest->latest; \ ref_pn(t); \ unref_pn((_p), (_pn)->latest); \ (_pn)->latest = t; \ }\ (_pn) = (_pn)->latest; \ } while (0) #ifndef USE_GC static void free_SNode(struct Parser *p, struct SNode *s); #define ref_pn(_pn) do { (_pn)->refcount++; } while (0) #define ref_sn(_sn) do { (_sn)->refcount++; } while (0) #define unref_pn(_p, _pn) do { if (!--(_pn)->refcount) free_PNode(_p, _pn); } while (0) #define unref_sn(_p, _sn) do { if (!--(_sn)->refcount) free_SNode(_p, _sn); } while (0) #else #define ref_pn(_pn) #define ref_sn(_sn) #define unref_pn(_p, _pn) #define unref_sn(_p, _sn) #endif typedef Stack(struct PNode*) StackPNode; typedef Stack(struct SNode*) StackSNode; typedef Stack(int) StackInt; static int exhaustive_parse(Parser *p, int state); static void free_PNode(Parser *p, PNode *pn); void print_paren(Parser *pp, PNode *p) { int i; char *c; LATEST(pp, p); if (!p->error_recovery) { if (p->children.n) { if (p->children.n > 1) printf("("); for (i = 0; i < p->children.n; i++) print_paren(pp, p->children.v[i]); if (p->children.n > 1) printf(")"); } else if (p->parse_node.start_loc.s != p->parse_node.end_skip) { printf(" "); for (c = p->parse_node.start_loc.s; c < p->parse_node.end_skip; c++) printf("%c", *c); printf(" "); } } } void xprint_paren(Parser *pp, PNode *p) { int i; char *c; LATEST(pp, p); if (!p->error_recovery) { printf("[%p %s]", p, pp->t->symbols[p->parse_node.symbol].name); if (p->children.n) { printf("("); for (i = 0; i < p->children.n; i++) xprint_paren(pp, p->children.v[i]); printf(")"); } else if (p->parse_node.start_loc.s != p->parse_node.end_skip) { printf(" "); for (c = p->parse_node.start_loc.s; c < p->parse_node.end_skip; c++) printf("%c", *c); printf(" "); } if (p->ambiguities) { printf(" |OR| "); xprint_paren(pp, p->ambiguities); } } } void xPP(Parser *pp, PNode *p) { xprint_paren(pp, p); printf("\n"); } void PP(Parser *pp, PNode *p) { print_paren(pp, p); printf("\n"); } #define D_ParseNode_to_PNode(_apn) \ ((PNode*)(D_PN(_apn, -(intptr_t)&((PNode*)(NULL))->parse_node))) #define PNode_to_D_ParseNode(_apn) \ ((D_ParseNode*)&((PNode*)(_apn))->parse_node) D_ParseNode * d_get_child(D_ParseNode *apn, int child) { PNode *pn = D_ParseNode_to_PNode(apn); if (child < 0 || child >= pn->children.n) return NULL; return &pn->children.v[child]->parse_node; } int d_get_number_of_children(D_ParseNode *apn) { PNode *pn = D_ParseNode_to_PNode(apn); return pn->children.n; } D_ParseNode * d_find_in_tree(D_ParseNode *apn, int symbol) { PNode *pn = D_ParseNode_to_PNode(apn); D_ParseNode *res; int i; if (pn->parse_node.symbol == symbol) return apn; for (i = 0; i < pn->children.n; i++) if ((res = d_find_in_tree(&pn->children.v[i]->parse_node, symbol))) return res; return NULL; } char * d_ws_before(D_Parser *ap, D_ParseNode *apn) { PNode *pn = D_ParseNode_to_PNode(apn); return pn->ws_before; } char * d_ws_after(D_Parser *ap, D_ParseNode *apn) { PNode *pn = D_ParseNode_to_PNode(apn); return pn->ws_after; } #define SNODE_HASH(_s, _sc, _g) ((((uintptr_t)(_s)) << 12) + (((uintptr_t)(_sc))) + ((uintptr_t)(_g))) SNode * find_SNode(Parser *p, uint state, D_Scope *sc, void *g) { SNodeHash *ph = &p->snode_hash; SNode *sn; uint h = SNODE_HASH(state, sc, g); if (ph->v) for (sn = ph->v[h % ph->m]; sn; sn = sn->bucket_next) if (sn->state - p->t->state == state && sn->initial_scope == sc && sn->initial_globals == g) return sn; return NULL; } void insert_SNode_internal(Parser *p, SNode *sn) { SNodeHash *ph = &p->snode_hash; uint h = SNODE_HASH(sn->state - p->t->state, sn->initial_scope, sn->initial_globals), i; SNode *t; if (ph->n + 1 > ph->m) { SNode **v = ph->v; int m = ph->m; ph->i++; ph->m = d_prime2[ph->i]; ph->v = (SNode**)MALLOC(ph->m * sizeof(*ph->v)); memset(ph->v, 0, ph->m * sizeof(*ph->v)); for (i = 0; i < m; i++) while ((t = v[i])) { v[i] = v[i]->bucket_next; insert_SNode_internal(p, t); } FREE(v); } sn->bucket_next = ph->v[h % ph->m]; assert(sn->bucket_next != sn); ph->v[h % ph->m] = sn; ph->n++; } static void insert_SNode(Parser *p, SNode *sn) { insert_SNode_internal(p, sn); ref_sn(sn); sn->all_next = p->snode_hash.all; p->snode_hash.all = sn; } static SNode * new_SNode(Parser *p, D_State *state, d_loc_t *loc, D_Scope *sc, void *g) { SNode *sn = p->free_snodes; if (!sn) sn = MALLOC(sizeof *sn); else p->free_snodes = sn->all_next; sn->depth = 0; vec_clear(&sn->zns); #ifndef USE_GC sn->refcount = 0; #endif sn->all_next = 0; p->states++; sn->state = state; sn->initial_scope = sc; sn->initial_globals = g; sn->last_pn = NULL; sn->loc = *loc; insert_SNode(p, sn); if (sn->state->accept) { if (!p->accept) { ref_sn(sn); p->accept = sn; } else if (sn->loc.s > p->accept->loc.s) { ref_sn(sn); unref_sn(p, p->accept); p->accept = sn; } } return sn; } static ZNode * new_ZNode(Parser *p, PNode *pn) { ZNode *z = p->free_znodes; if (!z) z = MALLOC(sizeof *z); else p->free_znodes = znode_next(z); z->pn = pn; ref_pn(pn); vec_clear(&z->sns); return z; } static void free_PNode(Parser *p, PNode *pn) { PNode *amb; int i; if (p->user.free_node_fn) p->user.free_node_fn(&pn->parse_node); for (i = 0; i < pn->children.n; i++) unref_pn(p, pn->children.v[i]); vec_free(&pn->children); if ((amb = pn->ambiguities)) { pn->ambiguities = NULL; unref_pn(p, amb); } if (pn->latest != pn) unref_pn(p, pn->latest); #ifdef USE_FREELISTS pn->all_next = p->free_pnodes; p->free_pnodes = pn; #else FREE(pn); #endif #ifdef TRACK_PNODES if (pn->xprev) pn->xprev->xnext = pn->xnext; else p->xall = pn->xnext; if (pn->xnext) pn->xnext->xprev = pn->xprev; pn->xprev = NULL; pn->xnext = NULL; #endif } #ifndef USE_GC static void free_ZNode(Parser *p, ZNode *z, SNode *s) { int i; unref_pn(p, z->pn); for (i = 0; i < z->sns.n; i++) if (s != z->sns.v[i]) unref_sn(p, z->sns.v[i]); vec_free(&z->sns); #ifdef USE_FREELISTS znode_next(z) = p->free_znodes; p->free_znodes = z; #else FREE(z); #endif } static void free_SNode(Parser *p, struct SNode *s) { int i; for (i = 0; i < s->zns.n; i++) if (s->zns.v[i]) free_ZNode(p, s->zns.v[i], s); vec_free(&s->zns); if (s->last_pn) unref_pn(p, s->last_pn); #ifdef USE_FREELISTS s->all_next = p->free_snodes; p->free_snodes = s; #else FREE(s); #endif } #else #define free_ZNode(_p, _z, _s) #endif #define PNODE_HASH(_si, _ei, _s, _sc, _g) \ ((((uintptr_t)_si) << 8) + (((uintptr_t)_ei) << 16) + (((uintptr_t)_s)) + (((uintptr_t)_sc)) + (((uintptr_t)_g))) PNode * find_PNode(Parser *p, char *start, char *end_skip, int symbol, D_Scope *sc, void *g, uint *hash) { PNodeHash *ph = &p->pnode_hash; PNode *pn; uint h = PNODE_HASH(start, end_skip, symbol, sc, g); *hash = h; if (ph->v) for (pn = ph->v[h % ph->m]; pn; pn = pn->bucket_next) if (pn->hash == h && pn->parse_node.symbol == symbol && pn->parse_node.start_loc.s == start && pn->parse_node.end_skip == end_skip && pn->initial_scope == sc && pn->initial_globals == g) { LATEST(p, pn); return pn; } return NULL; } void insert_PNode_internal(Parser *p, PNode *pn) { PNodeHash *ph = &p->pnode_hash; uint h = PNODE_HASH(pn->parse_node.start_loc.s, pn->parse_node.end_skip, pn->parse_node.symbol, pn->initial_scope, pn->initial_globals), i; PNode *t; if (ph->n + 1 > ph->m) { PNode **v = ph->v; int m = ph->m; ph->i++; ph->m = d_prime2[ph->i]; ph->v = (PNode**)MALLOC(ph->m * sizeof(*ph->v)); memset(ph->v, 0, ph->m * sizeof(*ph->v)); for (i = 0; i < m; i++) while ((t = v[i])) { v[i] = v[i]->bucket_next; insert_PNode_internal(p, t); } FREE(v); } pn->bucket_next = ph->v[h % ph->m]; ph->v[h % ph->m] = pn; ph->n++; } static void insert_PNode(Parser *p, PNode *pn) { insert_PNode_internal(p, pn); ref_pn(pn); pn->all_next = p->pnode_hash.all; p->pnode_hash.all = pn; } static void free_old_nodes(Parser *p) { int i; uint h; PNode *pn = p->pnode_hash.all, *tpn, **lpn; SNode *sn = p->snode_hash.all, *tsn, **lsn; while (sn) { h = SNODE_HASH(sn->state - p->t->state, sn->initial_scope, sn->initial_globals); lsn = &p->snode_hash.v[h % p->snode_hash.m]; tsn = sn; sn = sn->all_next; while (*lsn != tsn) lsn = &(*lsn)->bucket_next; *lsn = (*lsn)->bucket_next; } sn = p->snode_hash.last_all; p->snode_hash.last_all = 0; while (sn) { tsn = sn; sn = sn->all_next; unref_sn(p, tsn); } p->snode_hash.last_all = p->snode_hash.all; p->snode_hash.all = NULL; while (pn) { for (i = 0; i < pn->children.n; i++) { while (pn->children.v[i] != pn->children.v[i]->latest) { tpn = pn->children.v[i]->latest; ref_pn(tpn); unref_pn(p, pn->children.v[i]); pn->children.v[i] = tpn; } } h = PNODE_HASH(pn->parse_node.start_loc.s, pn->parse_node.end_skip, pn->parse_node.symbol, pn->initial_scope, pn->initial_globals); lpn = &p->pnode_hash.v[h % p->pnode_hash.m]; tpn = pn; pn = pn->all_next; while (*lpn != tpn) lpn = &(*lpn)->bucket_next; *lpn = (*lpn)->bucket_next; unref_pn(p, tpn); } p->pnode_hash.n = 0; p->pnode_hash.all = NULL; } static void alloc_parser_working_data(Parser *p) { p->pnode_hash.i = PNODE_HASH_INITIAL_SIZE_INDEX; p->pnode_hash.m = d_prime2[p->pnode_hash.i]; p->pnode_hash.v = (PNode**)MALLOC(p->pnode_hash.m * sizeof(*p->pnode_hash.v)); memset(p->pnode_hash.v, 0, p->pnode_hash.m * sizeof(*p->pnode_hash.v)); p->snode_hash.i = SNODE_HASH_INITIAL_SIZE_INDEX; p->snode_hash.m = d_prime2[p->snode_hash.i]; p->snode_hash.v = (SNode**)MALLOC(p->snode_hash.m * sizeof(*p->snode_hash.v)); memset(p->snode_hash.v, 0, p->snode_hash.m * sizeof(*p->snode_hash.v)); p->nshift_results = 0; p->ncode_shifts = 0; } static void free_parser_working_data(Parser *p) { int i; free_old_nodes(p); free_old_nodes(p); /* to catch SNodes saved for error repair */ if (p->pnode_hash.v) FREE(p->pnode_hash.v); if (p->snode_hash.v) FREE(p->snode_hash.v); memset(&p->pnode_hash, 0, sizeof(p->pnode_hash)); memset(&p->snode_hash, 0, sizeof(p->snode_hash)); while (p->reductions_todo) { Reduction *r = p->free_reductions->next; unref_sn(p, p->reductions_todo->snode); FREE(p->free_reductions); p->free_reductions = r; } while (p->shifts_todo) { Shift *s = p->free_shifts->next; unref_sn(p, p->shifts_todo->snode); FREE(p->free_shifts); p->free_shifts = s; } while (p->free_reductions) { Reduction *r = p->free_reductions->next; FREE(p->free_reductions); p->free_reductions = r; } while (p->free_shifts) { Shift *s = p->free_shifts->next; FREE(p->free_shifts); p->free_shifts = s; } while (p->free_pnodes) { PNode *pn = p->free_pnodes->all_next; FREE(p->free_pnodes); p->free_pnodes = pn; } while (p->free_znodes) { ZNode *zn = znode_next(p->free_znodes); FREE(p->free_znodes); p->free_znodes = zn; } while (p->free_snodes) { SNode *sn = p->free_snodes->all_next; FREE(p->free_snodes); p->free_snodes = sn; } for (i = 0; i < p->error_reductions.n; i++) FREE(p->error_reductions.v[i]); vec_free(&p->error_reductions); if (p->whitespace_parser) free_parser_working_data(p->whitespace_parser); FREE(p->shift_results); p->shift_results = NULL; p->nshift_results = 0; FREE(p->code_shifts); p->code_shifts = NULL; p->ncode_shifts = 0; } static int znode_depth(ZNode *z) { int i, d = 0; if (!z) return INT_MAX; for (i = 0; i < z->sns.n; i++) d = d < z->sns.v[i]->depth ? z->sns.v[i]->depth : d; return d; } static Reduction * add_Reduction(Parser *p, ZNode *z, SNode *sn, D_Reduction *reduction) { Reduction *x, **l = &p->reductions_todo; int d = znode_depth(z), dd; for (x = p->reductions_todo; x; l = &x->next, x = x->next) { if (sn->loc.s < x->snode->loc.s) break; dd = znode_depth(x->znode); if ((sn->loc.s == x->snode->loc.s && d >= dd)) { if (d == dd) while (x) { if (sn == x->snode && z == x->znode && reduction == x->reduction) return NULL; x = x->next; } break; } } { Reduction *r = p->free_reductions; if (!r) r = MALLOC(sizeof *r); else p->free_reductions = r->next; r->znode = z; r->snode = sn; r->new_snode = NULL; ref_sn(sn); r->reduction = reduction; r->next = *l; *l = r; return r; } } static void add_Shift(Parser *p, SNode *snode) { Shift *x, **l = &p->shifts_todo; Shift *s = p->free_shifts; if (!s) s = MALLOC(sizeof *s); else p->free_shifts = s->next; s->snode = snode; ref_sn(s->snode); for (x = p->shifts_todo; x; l = &x->next, x = x->next) if (snode->loc.s <= x->snode->loc.s) break; s->next = *l; *l = s; } static SNode * add_SNode(Parser *p, D_State *state, d_loc_t *loc, D_Scope *sc, void *g) { int i; SNode *sn = find_SNode(p, state - p->t->state, sc, g); if (sn) return sn; sn = new_SNode(p, state, loc, sc, g); if (sn->state->shifts) add_Shift(p, sn); for (i = 0; i < sn->state->reductions.n; i++) if (!sn->state->reductions.v[i]->nelements) add_Reduction(p, 0, sn, sn->state->reductions.v[i]); return sn; } static int reduce_actions(Parser *p, PNode *pn, D_Reduction *r) { int i, height = 0; PNode *c; for (i = 0; i < pn->children.n; i++) { c = pn->children.v[i]; if (c->op_assoc) { pn->assoc = c->op_assoc; pn->priority = c->op_priority; } if (c->height >= height) height = c->height + 1; } pn->op_assoc = r->op_assoc; pn->op_priority = r->op_priority; pn->height = height; if (r->rule_assoc) { pn->assoc = r->rule_assoc; pn->priority = r->rule_priority; } if (r->speculative_code) return r->speculative_code( pn, (void**)&pn->children.v[0], pn->children.n, (intptr_t)&((PNode*)(NULL))->parse_node, (D_Parser*)p); return 0; } #define x 666 /* impossible */ static int child_table[4][3][6] = { { /* binary parent, child on left */ /* priority of child vs parent, or = with child|parent associativity > < =LL =LR =RL =RR */ { 1, 0, 1, 1, 0, 0}, /* binary child */ { 1, 1, 1, 1, x, x}, /* left unary child */ { 1, 0, x, x, 1, 1} /* right unary child */ }, { /* binary parent, child on right */ { 1, 0, 0, 0, 1, 1}, /* binary child */ { 1, 0, 1, 1, x, x}, /* left unary child */ { 1, 1, x, x, 1, 1} /* right unary child */ }, { /* left unary parent */ { 1, 0, 0, x, 0, x}, /* binary child */ { 1, 1, 1, x, x, x}, /* left unary child */ { 1, 0, x, x, 1, x} /* right unary child */ }, { /* right unary parent */ { 1, 0, x, 0, x, 0}, /* binary child */ { 1, 0, x, 1, x, x}, /* left unary child */ { 1, 1, x, x, x, 1} /* right unary child */ } }; #undef x /* returns 1 if legal for child reduction and illegal for child shift */ static int check_child(int ppri, AssocKind passoc, int cpri, AssocKind cassoc, int left, int right) { int p = IS_BINARY_NARY_ASSOC(passoc) ? (right ? 1 : 0) : (passoc == ASSOC_UNARY_LEFT ? 2 : 3); int c = IS_BINARY_NARY_ASSOC(cassoc) ? 0 : (cassoc == ASSOC_UNARY_LEFT ? 1 : 2); int r = cpri > ppri ? 0 : ( cpri < ppri ? 1 : ( 2 + ( (IS_RIGHT_ASSOC(cassoc) ? 2 : 0) + (IS_RIGHT_ASSOC(passoc) ? 1 : 0)))); return child_table[p][c][r]; } /* check assoc/priority legality, 0 is OK, -1 is bad */ static int check_assoc_priority(PNode *pn0, PNode *pn1, PNode *pn2) { if (!IS_UNARY_BINARY_ASSOC(pn0->op_assoc)) { if (IS_UNARY_BINARY_ASSOC(pn1->op_assoc)) { /* second token is operator */ /* check expression pn0 (child of pn1) */ if (pn0->assoc) { if (!check_child(pn1->op_priority, pn1->op_assoc, pn0->priority, pn0->assoc, 0, 1)) return -1; } } } else { /* pn0 is an operator */ if (pn1->op_assoc) { /* check pn0 (child of operator pn1) */ if (!check_child(pn1->op_priority, pn1->op_assoc, pn0->op_priority, pn0->op_assoc, 0, 1)) return -1; } else if (pn2) { /* check pn0 (child of operator pn2) */ if (pn2->op_assoc && !check_child(pn2->op_priority, pn2->op_assoc, pn0->op_priority, pn0->op_assoc, 0, 1)) return -1; } /* check expression pn1 (child of pn0) */ if (pn1->assoc) { if (!check_child(pn0->op_priority, pn0->op_assoc, pn1->priority, pn1->assoc, 1, 0)) return -1; } } return 0; } /* check to see if a path is legal with respect to the associativity and priority of its operators */ static int check_path_priorities_internal(VecZNode *path) { int i = 0, j, k, jj, kk, one = 0; ZNode *z, *zz, *zzz; PNode *pn0, *pn1; if (path->n < i + 1) return 0; pn0 = path->v[i]->pn; if (!pn0->op_assoc) { /* deal with top expression directly */ i = 1; if (path->n < i + 1) return 0; pn1 = path->v[i]->pn; if (!pn1->op_assoc) return 0; if (pn0->assoc) { if (!check_child(pn1->op_priority, pn1->op_assoc, pn0->priority, pn0->assoc, 0, 1)) return -1; } pn0 = pn1; } if (path->n > i + 1) { /* entirely in the path */ pn1 = path->v[i + 1]->pn; if (path->n > i + 2) return check_assoc_priority(pn0, pn1, path->v[i + 2]->pn); else { /* one level from the stack beyond the path */ z = path->v[i + 1]; for (k = 0; k < z->sns.n; k++) for (j = 0; j < z->sns.v[k]->zns.n; j++) { one = 1; zz = z->sns.v[k]->zns.v[j]; if (zz && !check_assoc_priority(pn0, pn1, zz->pn)) return 0; } if (!one) return check_assoc_priority(pn0, pn1, NULL); } } else { /* two levels from the stack beyond the path */ z = path->v[i]; for (k = 0; k < z->sns.n; k++) for (j = 0; j < z->sns.v[k]->zns.n; j++) { zz = z->sns.v[k]->zns.v[j]; if (zz) for (kk = 0; kk < zz->sns.n; kk++) for (jj = 0; jj < zz->sns.v[kk]->zns.n; jj++) { one = 1; zzz = zz->sns.v[kk]->zns.v[jj]; if (zzz && !check_assoc_priority(pn0, zz->pn, zzz->pn)) return 0; } } return 0; } return -1; } /* avoid cases without operator priorities */ #define check_path_priorities(_p) ((_p)->n > 1 && \ ((_p)->v[0]->pn->op_assoc || (_p)->v[1]->pn->op_assoc) && \ check_path_priorities_internal(_p)) static int compare_priorities(int xpri[], int xn, int ypri[], int yn) { int i = 0; while (i < xn && i < yn) { if (xpri[i] > ypri[i]) return -1; if (xpri[i] < ypri[i]) return 1; i++; } return 0; } static void intreverse(int *xp, int n) { int *a = xp, *b = xp + n -1; while (a < b) { int t = *a; *a = *b; *b = t; a++; b--; } } /* sort by deepest, then by location */ static void priority_insert(StackPNode *psx, PNode *x) { PNode *t, **start, **cur; stack_push(psx, x); start = psx->start; cur = psx->cur; for (;cur > start + 1;cur--) { if (cur[-1]->height > cur[-2]->height) continue; if (cur[-1]->height == cur[-2]->height && cur[-1]->parse_node.start_loc.s > cur[-2]->parse_node.start_loc.s) continue; t = cur[-1]; cur[-1] = cur[-2]; cur[-2] = t; } } static void get_exp_all(Parser *p, PNode *x, StackInt *psx) { int i; if (x->assoc) stack_push(psx, x->priority); for (i = 0; i < x->children.n; i++) { PNode *pn = x->children.v[i]; LATEST(p, pn); get_exp_all(p, pn, psx); } } static void get_exp_one(Parser *p, PNode *x, StackPNode *psx, StackInt *isx) { int i; LATEST(p, x); if (!IS_NARY_ASSOC(x->assoc)) priority_insert(psx, x); else { stack_push(isx, x->priority); for (i = 0; i < x->children.n; i++) if (x->children.v[i]->assoc) get_exp_one(p, x->children.v[i], psx, isx); } } static void get_exp_one_down(Parser *p, PNode *x, StackPNode *psx, StackInt *isx) { int i; LATEST(p, x); stack_push(isx, x->priority); for (i = 0; i < x->children.n; i++) if (x->children.v[i]->assoc) get_exp_one(p, x->children.v[i], psx, isx); } /* get the set of priorities for unshared nodes, eliminating shared subtrees via priority queues */ static void get_unshared_priorities(Parser *p, StackPNode *psx, StackPNode *psy, StackInt *isx, StackInt *isy) { StackPNode *psr; PNode *t; while (1) { if (is_stack_empty(psx)) { psr = psy; break; } else if (is_stack_empty(psy)) { psr = psx; break; } if (stack_head(psx)->height > stack_head(psy)->height) psr = psx; else if (stack_head(psx)->height < stack_head(psy)->height) psr = psy; else if (stack_head(psx) > stack_head(psy)) psr = psx; else if (stack_head(psx) < stack_head(psy)) psr = psy; else { (void)stack_pop(psx); (void)stack_pop(psy); continue; } t = stack_pop(psr); if (psr == psx) get_exp_one_down(p, t, psx, isx); else get_exp_one_down(p, t, psy, isy); } while (!is_stack_empty(psr)) { t = stack_pop(psr); if (psr == psx) get_exp_all(p, t, isx); else get_exp_all(p, t, isy); } return; } /* compare the priorities of operators in two trees while eliminating common subtrees for efficiency. */ static int cmp_priorities(Parser *p, PNode *x, PNode *y) { StackPNode psx, psy; StackInt isx, isy; int r; stack_clear(&psx); stack_clear(&psy); stack_clear(&isx); stack_clear(&isy); get_exp_one(p, x, &psx, &isx); get_exp_one(p, y, &psy, &isy); get_unshared_priorities(p, &psx, &psy, &isx, &isy); intreverse(isx.start, stack_depth(&isx)); intreverse(isy.start, stack_depth(&isy)); r = compare_priorities(isx.start, stack_depth(&isx), isy.start, stack_depth(&isy)); stack_free(&psx); stack_free(&psy); stack_free(&isx); stack_free(&isy); return r; } static void get_all(Parser *p, PNode *x, VecPNode *vx) { int i; if (set_add(vx, x)) { for (i = 0; i < x->children.n; i++) { PNode *pn = x->children.v[i]; LATEST(p, pn); get_all(p, pn, vx); } } } static void get_unshared_pnodes(Parser *p, PNode *x, PNode *y, VecPNode *pvx, VecPNode *pvy) { int i; VecPNode vx, vy; vec_clear(&vx); vec_clear(&vy); LATEST(p, x); LATEST(p, y); get_all(p, x, &vx); get_all(p, y, &vy); for (i = 0; i < vx.n; i++) if (vx.v[i] && !set_find(&vy, vx.v[i])) vec_add(pvx, vx.v[i]); for (i = 0; i < vy.n; i++) if (vy.v[i] && !set_find(&vx, vy.v[i])) vec_add(pvy, vy.v[i]); vec_free(&vx); vec_free(&vy); } static int greedycmp(const void *ax, const void *ay) { PNode *x = *(PNode**)ax; PNode *y = *(PNode**)ay; // first by start if (x->parse_node.start_loc.s < y->parse_node.start_loc.s) return -1; if (x->parse_node.start_loc.s > y->parse_node.start_loc.s) return 1; // second by symbol if (x->parse_node.symbol < y->parse_node.symbol) return -1; if (x->parse_node.symbol > y->parse_node.symbol) return 1; // third by length if (x->parse_node.end < y->parse_node.end) return -1; if (x->parse_node.end > y->parse_node.end) return 1; return 0; } #define RET(_x) do { ret = (_x); goto Lreturn; } while (0) static int cmp_greediness(Parser *p, PNode *x, PNode *y) { VecPNode pvx, pvy; int ix = 0, iy = 0, ret = 0; vec_clear(&pvx); vec_clear(&pvy); get_unshared_pnodes(p, x, y, &pvx, &pvy); /* set_to_vec(&pvx); set_to_vec(&pvy); */ qsort(pvx.v, pvx.n, sizeof(PNode *), greedycmp); qsort(pvy.v, pvy.n, sizeof(PNode *), greedycmp); while (1) { if (pvx.n <= ix || pvy.n <= iy) RET(0); x = pvx.v[ix]; y = pvy.v[iy]; if (x == y) { ix++; iy++; } else if (x->parse_node.start_loc.s < y->parse_node.start_loc.s) ix++; else if (x->parse_node.start_loc.s > y->parse_node.start_loc.s) iy++; else if (x->parse_node.symbol < y->parse_node.symbol) ix++; else if (x->parse_node.symbol > y->parse_node.symbol) iy++; else if (x->parse_node.end > y->parse_node.end) RET(-1); else if (x->parse_node.end < y->parse_node.end) RET(1); else if (x->children.n < y->children.n) RET(-1); else if (x->children.n > y->children.n) RET(1); else { ix++; iy++; } } Lreturn: vec_free(&pvx); vec_free(&pvy); return ret; } int resolve_amb_greedy(D_Parser *dp, int n, D_ParseNode **v) { int i, result, selected_node= 0; for(i=1; iheight < D_ParseNode_to_PNode(v[selected_node])->height) ) selected_node = i; } return selected_node; } /* return -1 for x, 1 for y and 0 if they are ambiguous */ static int cmp_pnodes(Parser *p, PNode *x, PNode *y) { int r = 0; if (x->assoc && y->assoc) { if ((r = cmp_priorities(p, x, y))) return r; } if (!p->user.dont_use_greediness_for_disambiguation) if ((r = cmp_greediness(p, x, y))) return r; if (!p->user.dont_use_height_for_disambiguation) { if (x->height < y->height) return -1; if (x->height > y->height) return 1; } return r; } static PNode * make_PNode(Parser *p, uint hash, int symbol, d_loc_t *start_loc, char *e, PNode *pn, D_Reduction *r, VecZNode *path, D_Shift *sh, D_Scope *scope) { int i, l = sizeof(PNode) - sizeof(d_voidp) + p->user.sizeof_user_parse_node; PNode *new_pn = p->free_pnodes; if (!new_pn) new_pn = MALLOC(l); else p->free_pnodes = new_pn->all_next; p->pnodes++; memset(new_pn, 0, l); #ifdef TRACK_PNODES new_pn->xnext = p->xall; if (p->xall) p->xall->xprev = new_pn; p->xall = new_pn; #endif new_pn->hash = hash; new_pn->parse_node.symbol = symbol; new_pn->parse_node.start_loc = *start_loc; new_pn->ws_before = start_loc->ws; if (!r || !path) /* end of last parse node of path for non-epsilon reductions */ new_pn->parse_node.end = e; else new_pn->parse_node.end = pn->parse_node.end; new_pn->parse_node.end_skip = e; new_pn->shift = sh; new_pn->reduction = r; new_pn->parse_node.scope = pn->parse_node.scope; new_pn->initial_scope = scope; new_pn->parse_node.globals = pn->parse_node.globals; new_pn->initial_globals = new_pn->parse_node.globals; new_pn->parse_node.white_space = pn->parse_node.white_space; new_pn->latest = new_pn; new_pn->ws_after = e; if (sh) { new_pn->op_assoc = sh->op_assoc; new_pn->op_priority = sh->op_priority; if (sh->speculative_code && sh->action_index != -1) { D_Reduction dummy; memset(&dummy, 0, sizeof(dummy)); dummy.action_index = sh->action_index; new_pn->reduction = &dummy; if (sh->speculative_code( new_pn, (void**)&new_pn->children.v[0], new_pn->children.n, (intptr_t)&((PNode*)(NULL))->parse_node, (D_Parser*)p)) { free_PNode(p, new_pn); return NULL; } new_pn->reduction = NULL; } } else if (r) { if (path) for (i = path->n - 1; i >= 0; i--) { PNode *latest = path->v[i]->pn; LATEST(p, latest); ref_pn(latest); vec_add(&new_pn->children, latest); } if (reduce_actions(p, new_pn, r)) { free_PNode(p, new_pn); return NULL; } if (path && path->n > 1) { int n = path->n; for (i = 0; i < n; i += n-1) { PNode *child = new_pn->children.v[i]; if (child->assoc && !check_child(new_pn->priority, new_pn->assoc, child->priority, child->assoc, i == 0, i == n - 1)) { free_PNode(p, new_pn); return NULL; } } } } return new_pn; } static int PNode_equal(Parser *p, PNode *pn, D_Reduction *r, VecZNode *path, D_Shift *sh) { int i, n = pn->children.n; if (sh) return sh == pn->shift; if (r != pn->reduction) return 0; if (!path && !n) return 1; if (n == path->n) { for (i = 0; i < n; i++) { PNode *x = pn->children.v[i], *y = path->v[n - i - 1]->pn; LATEST(p, x); LATEST(p, y); if (x != y) return 0; } return 1; } return 0; } /* find/create PNode */ static PNode * add_PNode(Parser *p, int symbol, d_loc_t *start_loc, char *e, PNode *pn, D_Reduction *r, VecZNode *path, D_Shift *sh) { D_Scope *scope = equiv_D_Scope(pn->parse_node.scope); uint hash; PNode *old_pn = find_PNode(p, start_loc->s, e, symbol, scope, pn->parse_node.globals, &hash), *new_pn; if (old_pn) { PNode *amb = 0; if (PNode_equal(p, old_pn, r, path, sh)) return old_pn; for (amb = old_pn->ambiguities; amb; amb = amb->ambiguities) { if (PNode_equal(p, amb, r, path, sh)) return old_pn; } } new_pn = make_PNode(p, hash, symbol, start_loc, e, pn, r, path, sh, scope); if (!old_pn) { old_pn = new_pn; if (!new_pn) return NULL; insert_PNode(p, new_pn); goto Lreturn; } if (!new_pn) goto Lreturn; p->compares++; switch (cmp_pnodes(p, new_pn, old_pn)) { case 0: ref_pn(new_pn); new_pn->ambiguities = old_pn->ambiguities; old_pn->ambiguities = new_pn; break; case -1: insert_PNode(p, new_pn); LATEST(p,old_pn); ref_pn(new_pn); old_pn->latest = new_pn; old_pn = new_pn; break; case 1: free_PNode(p, new_pn); break; } Lreturn: return old_pn; } /* The set of znodes associated with a state can be very large because of cascade reductions (for example, large expression trees). Use an adaptive data structure starting with a short list and then falling back to a direct map hash table. */ static void set_add_znode(VecZNode *v, ZNode *z); static void set_union_znode(VecZNode *v, VecZNode *vv) { int i; for (i = 0; i < vv->n; i++) if (vv->v[i]) set_add_znode(v, vv->v[i]); } static ZNode * set_find_znode(VecZNode *v, PNode *pn) { uint i, j, n = v->n, h; if (n <= INTEGRAL_VEC_SIZE) { for (i = 0; i < n; i++) if (v->v[i]->pn == pn) return v->v[i]; return NULL; } h = ((uintptr_t)pn) % n; for (i = h, j = 0; i < v->n && j < SET_MAX_SEQUENTIAL; i = ((i + 1) % n), j++) { if (!v->v[i]) return NULL; else if (v->v[i]->pn == pn) return v->v[i]; } return NULL; } static void set_add_znode_hash(VecZNode *v, ZNode *z) { int i, j, n = v->n; VecZNode vv; vec_clear(&vv); if (n) { uint h = ((uintptr_t)z->pn) % n; for (i = h, j = 0; i < v->n && j < SET_MAX_SEQUENTIAL; i = ((i + 1) % n), j++) { if (!v->v[i]) { v->v[i] = z; return; } } } if (!n) { vv.v = NULL; v->i = INITIAL_SET_SIZE_INDEX; } else { vv.v = (void*)v->v; vv.n = v->n; v->i = v->i + 2; } v->n = d_prime2[v->i]; v->v = MALLOC(v->n * sizeof(void *)); memset(v->v, 0, v->n * sizeof(void *)); if (vv.v) { set_union_znode(v, &vv); FREE(vv.v); } set_add_znode(v, z); } static void set_add_znode(VecZNode *v, ZNode *z) { int i, n = v->n; VecZNode vv; vec_clear(&vv); if (n < INTEGRAL_VEC_SIZE) { vec_add(v, z); return; } if (n == INTEGRAL_VEC_SIZE) { vv = *v; vec_clear(v); for (i = 0; i < n; i++) set_add_znode_hash(v, vv.v[i]); } set_add_znode_hash(v, z); } #define GOTO_STATE(_p, _pn, _ps) \ ((_p)->t->goto_table[(_pn)->parse_node.symbol - \ (_ps)->state->goto_table_offset] - 1) static SNode * goto_PNode(Parser *p, d_loc_t *loc, PNode *pn, SNode *ps) { SNode *new_ps, *pre_ps; ZNode *z = NULL; D_State *state; int i, j, k, state_index; if (!IS_BIT_SET(ps->state->goto_valid, pn->parse_node.symbol)) return NULL; state_index = GOTO_STATE(p, pn, ps); state = &p->t->state[state_index]; new_ps = add_SNode(p, state, loc, pn->parse_node.scope, pn->parse_node.globals); if (new_ps->last_pn) unref_pn(p, new_ps->last_pn); ref_pn(pn); new_ps->last_pn = pn; DBG(printf("goto %d (%s) -> %d %p\n", (int)(ps->state - p->t->state), p->t->symbols[pn->parse_node.symbol].name, state_index, new_ps)); if (ps != new_ps && new_ps->depth < ps->depth + 1) new_ps->depth = ps->depth + 1; /* find/create ZNode */ z = set_find_znode(&new_ps->zns, pn); if (!z) { /* not found */ set_add_znode(&new_ps->zns, (z = new_ZNode(p, pn))); for (j = 0; j < new_ps->state->reductions.n; j++) if (new_ps->state->reductions.v[j]->nelements) add_Reduction(p, z, new_ps, new_ps->state->reductions.v[j]); if (!pn->shift) for (j = 0; j < new_ps->state->right_epsilon_hints.n; j++) { D_RightEpsilonHint *h = &new_ps->state->right_epsilon_hints.v[j]; pre_ps = find_SNode(p, h->preceeding_state, new_ps->initial_scope, new_ps->initial_globals); if (!pre_ps) continue; for (k = 0; k < pre_ps->zns.n; k++) if (pre_ps->zns.v[k]) { Reduction *r = add_Reduction(p, pre_ps->zns.v[k], pre_ps, h->reduction); if (r) { r->new_snode = new_ps; r->new_depth = h->depth; } } } } for (i = 0; i < z->sns.n; i++) if (z->sns.v[i] == ps) break; if (i >= z->sns.n) { /* not found */ vec_add(&z->sns, ps); if (new_ps != ps) ref_sn(ps); } return new_ps; } void parse_whitespace(D_Parser *ap, d_loc_t *loc, void **p_globals) { Parser *pp = ((Parser*)ap)->whitespace_parser; pp->start = loc->s; if (!exhaustive_parse(pp, ((Parser *)ap)->t->whitespace_state)) { if (pp->accept) { int old_col = loc->col, old_line = loc->line; *loc = pp->accept->loc; if (loc->line == 1) loc->col = old_col + loc->col; loc->line = old_line + (pp->accept->loc.line - 1); unref_sn(pp, pp->accept); pp->accept = NULL; } } } static void shift_all(Parser *p, char *pos) { int i, j, nshifts = 0, ncode = 0; d_loc_t loc, skip_loc; D_WhiteSpaceFn skip_fn = NULL; PNode *new_pn; D_State *state; ShiftResult *r; Shift *saved_s = p->shifts_todo, *s = saved_s, *ss; loc = s->snode->loc; skip_loc.s = NULL; for (; (s = p->shifts_todo) && s->snode->loc.s == pos;) { if (p->nshift_results - nshifts < p->t->nsymbols * 2) { p->nshift_results = nshifts + p->t->nsymbols * 3; p->shift_results = REALLOC(p->shift_results, p->nshift_results * sizeof(ShiftResult)); } p->shifts_todo = p->shifts_todo->next; p->scans++; state = s->snode->state; if (state->scanner_code) { if (p->ncode_shifts < ncode + 1) { p->ncode_shifts = ncode + 2; p->code_shifts = REALLOC(p->code_shifts, p->ncode_shifts * sizeof(D_Shift)); } p->code_shifts[ncode].shift_kind = D_SCAN_ALL; p->code_shifts[ncode].term_priority = 0; p->code_shifts[ncode].op_assoc = 0; p->code_shifts[ncode].action_index = 0; p->code_shifts[ncode].speculative_code = 0; p->shift_results[nshifts].loc = loc; if ((state->scanner_code( &p->shift_results[nshifts].loc, &p->code_shifts[ncode].symbol, &p->code_shifts[ncode].term_priority, &p->code_shifts[ncode].op_assoc, &p->code_shifts[ncode].op_priority))) { p->shift_results[nshifts].snode = s->snode; p->shift_results[nshifts++].shift = &p->code_shifts[ncode++]; } } if (state->scanner_table) { int n = scan_buffer(&loc, state, &p->shift_results[nshifts]); for (i = 0; i < n; i++) p->shift_results[nshifts + i].snode = s->snode; nshifts += n; } } for (i = 0; i < nshifts; i++) { r = &p->shift_results[i]; if (!r->shift) continue; if (r->shift->shift_kind == D_SCAN_TRAILING) { int symbol = r->shift->symbol; SNode *sn = r->snode; r->shift = 0; for (j = i + 1; j < nshifts; j++) { if (p->shift_results[j].shift && sn == p->shift_results[j].snode && symbol == p->shift_results[j].shift->symbol) { r->shift = p->shift_results[j].shift; p->shift_results[j].shift = 0; } } } if (r->shift && r->shift->term_priority) { /* potentially n^2 but typically small */ for (j = 0; j < nshifts; j++) { if (!p->shift_results[j].shift) continue; if (r->loc.s == p->shift_results[j].loc.s && j != i) { if (r->shift->term_priority < p->shift_results[j].shift->term_priority) { r->shift = 0; break; } if (r->shift->term_priority > p->shift_results[j].shift->term_priority) p->shift_results[j].shift = 0; } } } } for (i = 0; i < nshifts; i++) { r = &p->shift_results[i]; if (!r->shift) continue; p->shifts++; DBG(printf("shift %d %p %d (%s)\n", (int)(r->snode->state - p->t->state), r->snode, r->shift->symbol, p->t->symbols[r->shift->symbol].name)); new_pn = add_PNode(p, r->shift->symbol, &r->snode->loc, r->loc.s, r->snode->last_pn, NULL, NULL, r->shift); if (new_pn) { if (!skip_loc.s || skip_loc.s != r->loc.s || skip_fn != new_pn->parse_node.white_space) { skip_loc = r->loc; skip_fn = new_pn->parse_node.white_space; new_pn->parse_node.white_space( (D_Parser*)p, &skip_loc, (void**)&new_pn->parse_node.globals); skip_loc.ws = r->loc.s; new_pn->ws_before = loc.ws; new_pn->ws_after = skip_loc.s; } goto_PNode(p, &skip_loc, new_pn, r->snode); } } for (s = saved_s; s && s->snode->loc.s == pos;) { ss = s; s = s->next; unref_sn(p, ss->snode); ss->next = p->free_shifts; p->free_shifts = ss; } } static VecZNode path1; /* static first path for speed */ static VecZNode * new_VecZNode(VecVecZNode *paths, int n, int parent) { int i; VecZNode *pv; if (!paths->n) pv = &path1; else pv = MALLOC(sizeof *pv); vec_clear(pv); if (parent >= 0) for (i = 0; i < n; i++) vec_add(pv, paths->v[parent]->v[i]); return pv; } static void build_paths_internal(ZNode *z, VecVecZNode *paths, int parent, int n, int n_to_go) { int j, k, l; vec_add(paths->v[parent], z); if (n_to_go <= 1) return; for (k = 0; k < z->sns.n; k++) for (j = 0, l = 0; j < z->sns.v[k]->zns.n; j++) { if (z->sns.v[k]->zns.v[j]) { if (k + l) { vec_add(paths, new_VecZNode(paths, n - (n_to_go - 1), parent)); parent = paths->n - 1; } build_paths_internal(z->sns.v[k]->zns.v[j], paths, parent, n, n_to_go - 1); l++; } } } static void build_paths(ZNode *z, VecVecZNode *paths, int nchildren_to_go) { if (!nchildren_to_go) return; vec_add(paths, new_VecZNode(paths, 0, -1)); build_paths_internal(z, paths, 0, nchildren_to_go, nchildren_to_go); } static void free_paths(VecVecZNode *paths) { int i; vec_free(&path1); for (i = 1; i < paths->n; i++) { vec_free(paths->v[i]); FREE(paths->v[i]); } vec_free(paths); } static void reduce_one(Parser *p, Reduction *r) { SNode *sn = r->snode; PNode *pn, *last_pn; ZNode *first_z; int i, j, n = r->reduction->nelements; VecVecZNode paths; VecZNode *path; if (!r->znode) { /* epsilon reduction */ if ((pn = add_PNode(p, r->reduction->symbol, &sn->loc, sn->loc.s, sn->last_pn, r->reduction, 0, 0))) goto_PNode(p, &sn->loc, pn, sn); } else { DBG(printf("reduce %d %p %d\n", (int)(r->snode->state - p->t->state), sn, n)); vec_clear(&paths); build_paths(r->znode, &paths, n); for (i = 0; i < paths.n; i++) { path = paths.v[i]; if (r->new_snode) { /* prune paths by new right epsilon node */ for (j = 0; j < path->v[r->new_depth]->sns.n; j++) if (path->v[r->new_depth]->sns.v[j] == r->new_snode) break; if (j >= path->v[r->new_depth]->sns.n) continue; } if (check_path_priorities(path)) continue; p->reductions++; last_pn = path->v[0]->pn; first_z = path->v[n - 1]; pn = add_PNode(p, r->reduction->symbol, &first_z->pn->parse_node.start_loc, sn->loc.s, last_pn, r->reduction, path, NULL); if (pn) for (j = 0; j < first_z->sns.n; j++) goto_PNode(p, &sn->loc, pn, first_z->sns.v[j]); } free_paths(&paths); } unref_sn(p, sn); r->next = p->free_reductions; p->free_reductions = r; } static int VecSNode_equal(VecSNode *vsn1, VecSNode *vsn2) { int i, j; if (vsn1->n != vsn2->n) return 0; for (i = 0; i < vsn1->n; i++) { for (j = 0; j < vsn2->n; j++) { if (vsn1->v[i] == vsn2->v[j]) break; } if (j >= vsn2->n) return 0; } return 1; } static ZNode * binary_op_ZNode(SNode *sn) { ZNode *z; if (sn->zns.n != 1) return NULL; z = sn->zns.v[0]; if (z->pn->op_assoc == ASSOC_UNARY_RIGHT) { if (z->sns.n != 1) return NULL; sn = z->sns.v[0]; if (sn->zns.n != 1) return NULL; z = sn->zns.v[0]; } if (!IS_BINARY_ASSOC(z->pn->op_assoc)) return NULL; return z; } #ifdef D_DEBUG static const char *spaces = " "; static void print_stack(Parser *p, SNode *s, int indent) { int i,j; printf("%d", (int)(s->state - p->t->state)); indent += 2; for (i = 0; i < s->zns.n; i++) { if (!s->zns.v[i]) continue; if (s->zns.n > 1) printf("\n%s[", &spaces[99-indent]); printf("(%s:", p->t->symbols[s->zns.v[i]->pn->parse_node.symbol].name); print_paren(p, s->zns.v[i]->pn); printf(")"); for (j = 0; j < s->zns.v[i]->sns.n; j++) { if (s->zns.v[i]->sns.n > 1) printf("\n%s[", &spaces[98-indent]); print_stack(p, s->zns.v[i]->sns.v[j], indent); if (s->zns.v[i]->sns.n > 1) printf("]"); } if (s->zns.n > 1) printf("]"); } } #endif /* compare two stacks with operators on top of identical substacks eliminating the stack with the lower priority binary operator - used to eliminate unnecessary stacks created by the (empty) application binary operator */ static void cmp_stacks(Parser *p) { char *pos; Shift *a, *b, **al, **bl; ZNode *az, *bz; pos = p->shifts_todo->snode->loc.s; DBG({ int i = 0; for (al = &p->shifts_todo, a = *al; a && a->snode->loc.s == pos; al = &a->next, a = a->next) { if (++i < 2) printf("\n"); print_stack(p, a->snode, 0); printf("\n"); }}); for (al = &p->shifts_todo, a = *al; a && a->snode->loc.s == pos; al = &a->next, a = a->next) { if (!(az = binary_op_ZNode(a->snode))) continue; for (bl = &a->next, b = a->next; b && b->snode->loc.s == pos; bl = &b->next, b = b->next) { if (!(bz = binary_op_ZNode(b->snode))) continue; if (!VecSNode_equal(&az->sns, &bz->sns)) continue; if ((a->snode->state->reduces_to != b->snode->state - p->t->state) && (b->snode->state->reduces_to != a->snode->state - p->t->state)) continue; if (az->pn->op_priority > bz->pn->op_priority) { DBG(printf("DELETE "); print_stack(p, b->snode, 0); printf("\n")); *bl = b->next; unref_sn(p, b->snode); FREE(b); b = *bl; break; } if (az->pn->op_priority < bz->pn->op_priority) { DBG(printf("DELETE "); print_stack(p, a->snode, 0); printf("\n")); *al = a->next; unref_sn(p, a->snode); FREE(a); a = *al; goto Lbreak2; } } Lbreak2:; } } static void free_ParseTreeBelow(Parser *p, PNode *pn) { int i; PNode *amb; for (i = 0; i < pn->children.n; i++) unref_pn(p, pn->children.v[i]); vec_free(&pn->children); if ((amb = pn->ambiguities)) { pn->ambiguities = NULL; free_PNode(p, amb); } } void free_D_ParseTreeBelow(D_Parser *p, D_ParseNode *dpn) { free_ParseTreeBelow((Parser*)p, DPN_TO_PN(dpn)); } D_ParseNode * ambiguity_count_fn(D_Parser *pp, int n, D_ParseNode **v) { Parser *p = (Parser*)pp; p->ambiguities += n - 1; return v[0]; } D_ParseNode * ambiguity_abort_fn(D_Parser *pp, int n, D_ParseNode **v) { int i; if (d_verbose_level) { for (i = 0; i < n; i++) { print_paren((Parser *) pp, D_ParseNode_to_PNode(v[i])); printf("\n"); } } d_fail("unresolved ambiguity line %d file %s", v[0]->start_loc.line, v[0]->start_loc.pathname); return v[0]; } static int final_actionless(PNode *pn) { int i; if (pn->reduction && pn->reduction->final_code) return 0; for (i = 0; i < pn->children.n; i++) if (!final_actionless(pn->children.v[i])) return 0; return 1; } static PNode * resolve_ambiguities(Parser *p, PNode *pn) { PNode *amb; D_ParseNode *res; int efa; Vec(D_ParseNode*) pns; vec_clear(&pns); efa = is_epsilon_PNode(pn) && final_actionless(pn); vec_add(&pns, &pn->parse_node); for (amb = pn->ambiguities; amb; amb = amb->ambiguities) { int i, found = 0; LATEST(p, amb); if (!p->user.dont_merge_epsilon_trees) if (efa && is_epsilon_PNode(amb) && final_actionless(amb)) continue; for (i = 0; i < pns.n; i++) if (pns.v[i] == &amb->parse_node) found = 1; if (!found) vec_add(&pns, &amb->parse_node); } if (pns.n == 1) { res = pns.v[0]; goto Ldone; } res = p->user.ambiguity_fn((D_Parser *)p, pns.n, pns.v); Ldone: vec_free(&pns); return D_ParseNode_to_PNode(res); } static void fixup_internal_symbol(Parser *p, PNode *pn, int ichild) { PNode *child = pn->children.v[ichild]; int j, n, pnn; n = child->children.n, pnn = pn->children.n; if (pn == child) d_fail("circular parse: unable to fixup internal symbol"); if (n == 0) { for (j = ichild; j < pnn - 1; j++) pn->children.v[j] = pn->children.v[j + 1]; pn->children.n--; } else if (n == 1) { ref_pn(child->children.v[0]); pn->children.v[ichild] = child->children.v[0]; } else { for (j = 0; j < n - 1; j++) /* expand children vector */ vec_add(&pn->children, NULL); for (j = pnn - 1; j >= ichild + 1; j--) /* move to new places */ pn->children.v[j - 1 + n] = pn->children.v[j]; for (j = 0; j < n; j++) { ref_pn(child->children.v[j]); pn->children.v[ichild + j] = child->children.v[j]; } } unref_pn(p, child); } #define is_symbol_internal_or_EBNF(_p, _pn) \ ((_p)->t->symbols[(_pn)->parse_node.symbol].kind == D_SYMBOL_INTERNAL || \ (_p)->t->symbols[(_pn)->parse_node.symbol].kind == D_SYMBOL_EBNF) #define is_symbol_internal(_p, _pn) \ ((_p)->t->symbols[(_pn)->parse_node.symbol].kind == D_SYMBOL_INTERNAL) #define is_unreduced_epsilon_PNode(_pn) \ (is_epsilon_PNode(_pn) && ((_pn)->reduction && (_pn)->reduction->final_code)) static PNode * commit_tree(Parser *p, PNode *pn) { int i, fixup_ebnf = 0, fixup = 0, internal = 0; LATEST(p, pn); if (pn->evaluated) return pn; if (!is_unreduced_epsilon_PNode(pn)) pn->evaluated = 1; if (pn->ambiguities) pn = resolve_ambiguities(p, pn); fixup_ebnf = p->user.fixup_EBNF_productions; internal = is_symbol_internal_or_EBNF(p, pn); fixup = !p->user.dont_fixup_internal_productions && internal; for (i = 0; i < pn->children.n; i++) { PNode *tpn = commit_tree(p, pn->children.v[i]); if (tpn != pn->children.v[i]){ ref_pn(tpn); unref_pn(p, pn->children.v[i]); pn->children.v[i] = tpn; } if (fixup && (fixup_ebnf ? is_symbol_internal_or_EBNF(p, pn->children.v[i]) : is_symbol_internal(p, pn->children.v[i]))) { fixup_internal_symbol(p, pn, i); i -= 1; continue; } } if (pn->reduction) DBG(printf("commit %p (%s)\n", pn, p->t->symbols[pn->parse_node.symbol].name)); if (pn->reduction && pn->reduction->final_code) pn->reduction->final_code( pn, (void**)&pn->children.v[0], pn->children.n, (intptr_t)&((PNode*)(NULL))->parse_node, (D_Parser*)p); if (pn->evaluated) { if (!p->user.save_parse_tree && !internal) free_ParseTreeBelow(p, pn); } return pn; } static int commit_stack(Parser *p, SNode *sn) { int res = 0; PNode *tpn; if (sn->zns.n != 1) return -1; if (sn->zns.v[0]->sns.n > 1) return -2; if (is_unreduced_epsilon_PNode(sn->zns.v[0]->pn)) /* wait till reduced */ return -3; if (sn->zns.v[0]->sns.n) if ((res = commit_stack(p, sn->zns.v[0]->sns.v[0])) < 0) return res; tpn = commit_tree(p, sn->zns.v[0]->pn); if (tpn != sn->zns.v[0]->pn){ ref_pn(tpn); unref_pn(p, sn->zns.v[0]->pn); sn->zns.v[0]->pn = tpn; } return res; } static const char * find_substr(const char *str, const char *s) { int len = strlen(s); if (len == 1) { while (*str && *str != *s) str++; if (*str == *s) return str + 1; } else while (*str) { if (!strncmp(s, str, len)) return str + len; str++; } return NULL; } static void syntax_error_report_fn(struct D_Parser *ap) { Parser *p = (Parser *)ap; char *fn = d_dup_pathname_str(p->user.loc.pathname); char *after = 0; ZNode *z = p->snode_hash.last_all ? p->snode_hash.last_all->zns.v[0] : 0; while (z && z->pn->parse_node.start_loc.s == z->pn->parse_node.end) z = (z->sns.v && z->sns.v[0]->zns.v) ? z->sns.v[0]->zns.v[0] : 0; if (z && z->pn->parse_node.start_loc.s != z->pn->parse_node.end) after = dup_str(z->pn->parse_node.start_loc.s, z->pn->parse_node.end); if (after) fprintf(stderr, "%s:%d: syntax error after '%s'\n", fn, p->user.loc.line, after); else fprintf(stderr, "%s:%d: syntax error\n", fn, p->user.loc.line); if (after) FREE(after); FREE(fn); } static void update_line(const char *s, const char *e, int *line) { for (;s < e; s++) if (*s == '\n') (*line)++; } static int error_recovery(Parser *p) { SNode *sn, *best_sn = NULL; const char *best_s = NULL, *ss, *s; int i, j, head = 0, tail = 0, res = 1; D_ErrorRecoveryHint *best_er = NULL; SNode **q = 0; PNode *best_pn; if (!p->snode_hash.last_all) return res; p->user.loc = p->snode_hash.last_all->loc; if (!p->user.error_recovery) return res; q = MALLOC(ERROR_RECOVERY_QUEUE_SIZE * sizeof(SNode*)); if (p->user.loc.line > p->last_syntax_error_line) { p->last_syntax_error_line = p->user.loc.line; p->user.syntax_errors++; p->user.syntax_error_fn((D_Parser*)p); } for (sn = p->snode_hash.last_all; sn; sn = sn->all_next) { if (tail < ERROR_RECOVERY_QUEUE_SIZE - 1) q[tail++] = sn; } s = p->snode_hash.last_all->loc.s; while (tail > head) { sn = q[head++]; if (sn->state->error_recovery_hints.n) { for (i = 0; i < sn->state->error_recovery_hints.n; i++) { D_ErrorRecoveryHint *er = &sn->state->error_recovery_hints.v[i]; if ((ss = find_substr(s, er->string))) { if (!best_sn || ss < best_s || (best_sn && ss == best_s && (best_sn->depth < sn->depth || (best_sn->depth == sn->depth && best_er->depth < er->depth)))) { best_sn = sn; best_s = ss; best_er = er; } } } } for (i = 0; i < sn->zns.n; i++) if (sn->zns.v[i]) for (j = 0; j < sn->zns.v[i]->sns.n; j++) { if (tail < ERROR_RECOVERY_QUEUE_SIZE - 1) q[tail++] = sn->zns.v[i]->sns.v[j]; } } if (best_sn) { D_Reduction *rr = MALLOC(sizeof(*rr)); Reduction *r = MALLOC(sizeof(*r)); d_loc_t best_loc = p->user.loc; PNode *new_pn; SNode *new_sn; ZNode *z; memset(rr, 0, sizeof(*rr)); vec_add(&p->error_reductions, rr); rr->nelements = best_er->depth + 1; rr->symbol = best_er->symbol; update_line(best_loc.s, best_s, &best_loc.line); best_loc.s = (char*)best_s; for (i = 0; i < best_sn->zns.n; i++) if (best_sn->zns.v[i]) { best_pn = best_sn->zns.v[i]->pn; break; } best_pn->parse_node.white_space( (D_Parser*)p, &best_loc, (void**)&best_pn->parse_node.globals); new_pn = add_PNode(p, 0, &p->user.loc, best_loc.s, best_pn, 0, 0, 0); new_sn = new_SNode(p, best_sn->state, &best_loc, new_pn->initial_scope, new_pn->initial_globals); ref_pn(new_pn); new_sn->last_pn = new_pn; set_add_znode(&new_sn->zns, (z = new_ZNode(p, new_pn))); vec_add(&z->sns, best_sn); ref_sn(best_sn); r->znode = z; ref_sn(new_sn); r->snode = new_sn; r->reduction = rr; r->new_snode = NULL; r->next = NULL; free_old_nodes(p); free_old_nodes(p); reduce_one(p, r); for (i = 0; i < p->snode_hash.m; i++) for (sn = p->snode_hash.v[i]; sn; sn = sn->bucket_next) for (j = 0; j < sn->zns.n; j++) if ((z = sn->zns.v[j])) if (z->pn->reduction == rr) { z->pn->evaluated = 1; z->pn->error_recovery = 1; } if (p->shifts_todo || p->reductions_todo) res = 0; } FREE(q); return res; } #define PASS_CODE_FOUND(_p, _pn) ((_pn)->reduction && (_pn)->reduction->npass_code > (_p)->index && \ (_pn)->reduction->pass_code[(_p)->index]) static void pass_call(Parser *p, D_Pass *pp, PNode *pn) { if (PASS_CODE_FOUND(pp, pn)) pn->reduction->pass_code[pp->index]( pn, (void**)&pn->children.v[0], pn->children.n, (intptr_t)&((PNode*)(NULL))->parse_node, (D_Parser*)p); } static void pass_preorder(Parser *p, D_Pass *pp, PNode *pn) { int found = PASS_CODE_FOUND(pp, pn), i; pass_call(p, pp, pn); if ((pp->kind & D_PASS_FOR_ALL) || ((pp->kind & D_PASS_FOR_UNDEFINED) && !found)) for (i = 0; i < pn->children.n; i++) pass_preorder(p, pp, pn->children.v[i]); } static void pass_postorder(Parser *p, D_Pass *pp, PNode *pn) { int found = PASS_CODE_FOUND(pp, pn), i; if ((pp->kind & D_PASS_FOR_ALL) || ((pp->kind & D_PASS_FOR_UNDEFINED) && !found)) for (i = 0; i < pn->children.n; i++) pass_postorder(p, pp, pn->children.v[i]); pass_call(p, pp, pn); } void d_pass(D_Parser *ap, D_ParseNode *apn, int pass_number) { PNode *pn = D_ParseNode_to_PNode(apn); Parser *p = (Parser*)ap; D_Pass *pp; if (pass_number >= p->t->npasses) d_fail("bad pass number: %d\n", pass_number); pp = &p->t->passes[pass_number]; if (pp->kind & D_PASS_MANUAL) pass_call(p, pp, pn); else if (pp->kind & D_PASS_PRE_ORDER) pass_preorder(p, pp, pn); else if (pp->kind & D_PASS_POST_ORDER) pass_postorder(p, pp, pn); } static int exhaustive_parse(Parser *p, int state) { Reduction *r; char *pos, *epos = NULL; PNode *pn, tpn; SNode *sn; ZNode *z; int progress = 0, ready = 0; d_loc_t loc; pos = p->user.loc.ws = p->user.loc.s = p->start; loc = p->user.loc; p->user.initial_white_space_fn((D_Parser*)p, &loc, &p->user.initial_globals); /* initial state */ sn = add_SNode(p, &p->t->state[state], &loc, p->top_scope, p->user.initial_globals); memset(&tpn, 0, sizeof(tpn)); tpn.parse_node.white_space = p->user.initial_white_space_fn; tpn.parse_node.globals = p->user.initial_globals; tpn.initial_scope = tpn.parse_node.scope = p->top_scope; tpn.parse_node.end = loc.s; if (sn->last_pn) unref_pn(p, sn->last_pn); pn = add_PNode(p, 0, &loc, loc.s, &tpn, 0, 0, 0); ref_pn(pn); sn->last_pn = pn; set_add_znode(&sn->zns, (z = new_ZNode(p, pn))); while (1) { /* reduce all */ while (p->reductions_todo) { pos = p->reductions_todo->snode->loc.s; if (p->shifts_todo && p->shifts_todo->snode->loc.s < pos) break; if (pos > epos) { epos = pos; free_old_nodes(p); } for (;(r = p->reductions_todo) && r->snode->loc.s == pos;) { p->reductions_todo = p->reductions_todo->next; reduce_one(p, r); } } /* done? */ if (!p->shifts_todo) { if (p->accept && (p->accept->loc.s == p->end || p->user.partial_parses)) return 0; else { if (error_recovery(p)) return 1; continue; } } else if (!p->user.dont_compare_stacks && p->shifts_todo->next) cmp_stacks(p); /* shift all */ pos = p->shifts_todo->snode->loc.s; if (pos > epos) { epos = pos; free_old_nodes(p); } progress++; ready = progress > p->user.commit_actions_interval; if (ready && !p->shifts_todo->next && !p->reductions_todo) { commit_stack(p, p->shifts_todo->snode); ready = progress = 0; } shift_all(p, pos); if (ready && p->reductions_todo && !p->reductions_todo->next) { commit_stack(p, p->reductions_todo->snode); progress = 0; } } } /* doesn't include nl */ char _wspace[256] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 /* zero padded */ }; #define wspace(_x) (_wspace[(unsigned char)_x]) static void white_space(D_Parser *p, d_loc_t *loc, void **p_user_globals) { int rec = 0; char *s = loc->s, *scol = 0; if (*s == '#' && loc->col == 0) { Ldirective: { char *save = s; s++; while (wspace(*s)) s++; if (!strncmp("line", s, 4)) { if (wspace(s[4])) { s += 5; while (wspace(*s)) s++; } } if (isdigit_(*s)) { loc->line = atoi(s) - 1; while (isdigit_(*s)) s++; while (wspace(*s)) s++; if (*s == '"') loc->pathname = s; } else { s = save; goto Ldone; } } while (*s && *s != '\n') s++; } Lmore: while (wspace(*s)) s++; if (*s == '\n') { loc->line++; scol = s + 1; s++; if (*s == '#') goto Ldirective; else goto Lmore; } if (s[0] == '/') { if (s[1] == '/') { while (*s && *s != '\n') { s++; } goto Lmore; } if (s[1] == '*') { s += 2; LnestComment: rec++; LmoreComment: while (*s) { if (s[0] == '*' && s[1] == '/') { s += 2; rec--; if (!rec) goto Lmore; goto LmoreComment; } if (s[0] == '/' && s[1] == '*') { s += 2; goto LnestComment; } if (*s == '\n') { loc->line++; scol = s + 1; } s++; } } } Ldone: if (scol) loc->col = s - scol; else loc->col += s - loc->s; loc->s = s; return; } void null_white_space(D_Parser *p, d_loc_t *loc, void **p_globals) { } D_Parser * new_D_Parser(D_ParserTables *t, int sizeof_ParseNode_User) { Parser *p = MALLOC(sizeof(Parser)); memset(p, 0, sizeof(Parser)); p->t = t; p->user.loc.line = 1; p->user.sizeof_user_parse_node = sizeof_ParseNode_User; p->user.commit_actions_interval = DEFAULT_COMMIT_ACTIONS_INTERVAL; p->user.syntax_error_fn = syntax_error_report_fn; p->user.ambiguity_fn = ambiguity_abort_fn; p->user.error_recovery = 1; p->user.save_parse_tree = t->save_parse_tree; if (p->t->default_white_space) p->user.initial_white_space_fn = p->t->default_white_space; else if (p->t->whitespace_state) p->user.initial_white_space_fn = parse_whitespace; else p->user.initial_white_space_fn = white_space; return (D_Parser*)p; } void free_D_Parser(D_Parser *ap) { Parser *p = (Parser *)ap; if (p->top_scope && !p->user.initial_scope) free_D_Scope(p->top_scope, 0); if (p->whitespace_parser) free_D_Parser((D_Parser*)p->whitespace_parser); FREE(ap); } void free_D_ParseNode(D_Parser * p, D_ParseNode *dpn) { if (dpn != NO_DPN) { unref_pn((Parser*)p, DPN_TO_PN(dpn)); free_parser_working_data((Parser*)p); } #ifdef TRACK_PNODES if (((Parser*)p)->xall) printf("tracked pnodes\n"); #endif } static void copy_user_configurables(Parser *pp, Parser *p) { memcpy(((char*)&pp->user.start_state) + sizeof(pp->user.start_state), ((char*)&p->user.start_state) + sizeof(p->user.start_state), ((char*)&pp->user.syntax_errors - (char*)&pp->user.start_state)); } Parser * new_subparser(Parser *p) { Parser * pp = (Parser *)new_D_Parser(p->t, p->user.sizeof_user_parse_node); copy_user_configurables(pp, p); pp->end = p->end; pp->pinterface1 = p->pinterface1; alloc_parser_working_data(pp); return pp; } static void initialize_whitespace_parser(Parser *p) { if (p->t->whitespace_state) { p->whitespace_parser = new_subparser(p); p->whitespace_parser->user.initial_white_space_fn = null_white_space; p->whitespace_parser->user.error_recovery = 0; p->whitespace_parser->user.partial_parses = 1; p->whitespace_parser->user.free_node_fn = p->user.free_node_fn; } } static void free_whitespace_parser(Parser *p) { if (p->whitespace_parser) { free_D_Parser((D_Parser*)p->whitespace_parser); p->whitespace_parser = 0; } } static PNode * handle_top_level_ambiguities(Parser *p, SNode *sn) { int i; ZNode *z = 0; PNode *pn = NULL, *last = NULL, *x; for (i = 0; i < sn->zns.n; i++) { if (sn->zns.v[i]) { x = sn->zns.v[i]->pn; LATEST(p, x); if (!pn) { z = sn->zns.v[i]; pn = x; } else { if (x != pn && !x->ambiguities && x != last) { x->ambiguities = pn->ambiguities; ref_pn(x); pn->ambiguities = x; if (!last) last = x; } free_ZNode(p, sn->zns.v[i], sn); } } } sn->zns.v[0] = z; sn->zns.n = 1; sn->zns.i = 0; return pn; } D_ParseNode * dparse(D_Parser *ap, char *buf, int buf_len) { int r; Parser *p = (Parser *)ap; SNode *sn; PNode *pn; D_ParseNode *res = NULL; p->states = p->scans = p->shifts = p->reductions = p->compares = 0; p->start = buf; p->end = buf + buf_len; initialize_whitespace_parser(p); alloc_parser_working_data(p); if (p->user.initial_scope) p->top_scope = p->user.initial_scope; else { if (p->top_scope) free_D_Scope(p->top_scope, 0); p->top_scope = new_D_Scope(NULL); p->top_scope->kind = D_SCOPE_SEQUENTIAL; } r = exhaustive_parse(p, p->user.start_state); if (!r) { sn = p->accept; if (sn->zns.n != 1) pn = handle_top_level_ambiguities(p, sn); else pn = sn->zns.v[0]->pn; pn = commit_tree(p, pn); if (d_verbose_level) { printf( "%d states %d scans %d shifts %d reductions " "%d compares %d ambiguities\n", p->states, p->scans, p->shifts, p->reductions, p->compares, p->ambiguities); if (p->user.save_parse_tree) { if (d_verbose_level > 1) xprint_paren(p, pn); else print_paren(p, pn); printf("\n"); } } if (p->user.save_parse_tree) { ref_pn(pn); res = &pn->parse_node; } else res = NO_DPN; unref_sn(p, p->accept); p->accept = NULL; } else p->accept = NULL; free_parser_working_data(p); free_whitespace_parser(p); return res; } mcrl2-201210.1/3rd-party/dparser/util.h000775 001751 001751 00000007370 12042421220 020541 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2006 John Plevyak, All Rights Reserved */ #define INITIAL_SET_SIZE_INDEX 2 #define INITIAL_VEC_SHIFT 3 #define INITIAL_VEC_SIZE (1 << INITIAL_VEC_SHIFT) #define INITIAL_VEC_SIZE (1 << INITIAL_VEC_SHIFT) #define INTEGRAL_VEC_SIZE 3 #define INTEGRAL_STACK_SIZE 8 #define TRICK_VEC_SIZE (INITIAL_VEC_SIZE - INTEGRAL_VEC_ELEMENTS) #define SET_MAX_SEQUENTIAL 5 #define IS_BIT_SET(_v, _s) ((_v)[(_s) / 8] & 1 << ((_s) % 8)) #define SET_BIT(_v, _s) (_v)[(_s) / 8] |= (1 << ((_s) %8)) typedef struct AbstractVec { uint n; uint i; /* size index for use with sets */ void **v; void *e[INTEGRAL_VEC_SIZE]; } AbstractVec; #define Vec(_x) struct { \ uint n; \ uint i; \ _x *v; \ _x e[INTEGRAL_VEC_SIZE]; \ } typedef struct AbstractStack { void **start; void **end; void **cur; void *initial[INTEGRAL_STACK_SIZE]; } AbstractStack; #define Stack(_x) struct { \ _x *start; _x *end; _x *cur; _x initial[INTEGRAL_STACK_SIZE]; \ } #define vec_move(_a, _b) do { \ (_a)->n = (_b)->n; \ if ((_b)->v == (_b)->e) { \ memcpy(&(_a)->e[0], &(_b)->e[0], sizeof((_a)->e)); \ (_a)->v = (_a)->e; \ } else (_a)->v = (_b)->v; \ vec_clear(_b); \ } while (0) struct hash_fns_t; typedef uint32 (*hash_fn_t)(void *, struct hash_fns_t*); typedef int (*cmp_fn_t)(void *, void *, struct hash_fns_t*); typedef struct hash_fns_t { hash_fn_t hash_fn; cmp_fn_t cmp_fn; void *data[2]; } hash_fns_t; #define vec_add(_v, _i) do { \ if (!(_v)->v) { \ ((_v)->v = (_v)->e)[(_v)->n++] = (_i); \ break; \ } else if ((_v)->v == ((_v)->e)) { \ if (((_v)->n < INTEGRAL_VEC_SIZE)) { \ (_v)->v[(_v)->n++] = (_i); \ break; \ } \ } else if ((_v)->n & (INITIAL_VEC_SIZE - 1)) { \ (_v)->v[(_v)->n++] = (_i); \ break; \ } \ vec_add_internal((_v), _i); \ } while (0) void vec_add_internal(void *v, void *elem); int vec_eq(void *v, void *vv); int set_find(void *v, void *t); int set_add(void *v, void *t); int set_union(void *v, void *vv); void *set_add_fn(void *v, void *t, hash_fns_t *fns); void set_union_fn(void *v, void *vv, hash_fns_t *fns); void set_to_vec(void *av); #define vec_clear(_v) do { (_v)->n = 0; (_v)->v = 0; } while(0) #define vec_free(_v) do { \ if ((_v)->v && (_v)->v != (_v)->e) FREE((_v)->v); vec_clear(_v); } while(0) #define stack_clear(_s) do { \ (_s)->start = (_s)->cur = (_s)->end = (_s)->initial; \ (_s)->end += INTEGRAL_STACK_SIZE; \ } \ while(0) #define stack_free(_s) do { \ if ((_s)->start != (_s)->initial) FREE((_s)->start); \ stack_clear(_s); \ } while(0) #define stack_head(_s) ((_s)->cur[-1]) #define is_stack_empty(_s) ((_s)->cur == (_s)->start) #define stack_empty(_s) ((_s)->cur = (_s)->start) #define stack_depth(_s) ((_s)->cur - (_s)->start) #define stack_pop(_s) (*--((_s)->cur)) #define stack_push(_s, _x) do { if ((_s)->cur == (_s)->end ) \ stack_push_internal((AbstractStack*)((_s)), (void*)(uintptr_t)(_x)); else \ (*((_s)->cur)++ = (_x)); } while(0) void * stack_push_internal(AbstractStack*, void*); int buf_read(const char *pathname, char **buf, int *len); char *sbuf_read(const char *pathname); #define STREQ(_x,_n,_s) \ ((_n == sizeof(_s)-1) && !strncasecmp(_x,_s,sizeof(_s)-1)) void d_fail(const char *str, ...); void d_warn(const char *str, ...); char *dup_str(const char *str, const char *end); uint strhashl(const char *s, int len); void d_free(void *); void int_list_diff(int *a, int *b, int *c); void int_list_intersect(int *a, int *b, int *c); int *int_list_dup(int *aa); char *escape_string(char *s); char *escape_string_single_quote(char *s); extern uint d_prime2[]; extern int d_verbose_level; extern int d_debug_level; extern int test_level; extern int d_rdebug_grammar_level; mcrl2-201210.1/3rd-party/dparser/symtab.c000775 001751 001751 00000025451 12042421220 021056 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ #include "d.h" #define INITIAL_SYMHASH_SIZE 3137 typedef struct D_SymHash { int index; int grow; Vec(D_Sym*) syms; } D_SymHash; /* How this works. In a normal symbol table there is simply a stack of scopes representing the scoping structure of the program. Because of speculative parsing, this symbol table also has a tree of all 'updates' representing different views of the state of scoped variables by each speculative parse state. Periodically, when the parse state collapses to a single state (we are nolonger speculating), these changes are can be 'committed' and the changes pushed into the top level hash table. All D_Scope's except the top level just have a 'll' of symbols, the top level has a 'hash'. 'updates' is a list of changes to symbols in other scopes. It is searched to find the current version of a symbol with respect to the speculative parse path represented by D_Scope. 'up' points to the enclosing scope, it isn't used much. 'up_updates' is the prior scope in speculative parsing, it is used find the next D_Scope to look in for 'updates' after the current one has been searched. 'down' and 'down_next' are used to hold enclosing scopes, or in the case of the top level, sibling scopes (created by commmit). */ static void symhash_add(D_SymHash *sh, D_Sym *s) { uint i, h = s->hash % sh->syms.n, n; D_Sym **v = sh->syms.v, *x; Vec(D_Sym*) vv, tv; sh->index++; s->next = v[h]; v[h] = s; if (sh->index > sh->grow) { vv.v = sh->syms.v; vv.n = sh->syms.n; sh->syms.n = sh->grow; sh->grow = sh->grow * 2 + 1; sh->syms.v = MALLOC(sh->syms.n * sizeof(void *)); memset(sh->syms.v, 0, sh->syms.n * sizeof(void *)); v = sh->syms.v; n = sh->syms.n; vec_clear(&tv); for (i = 0; i < vv.n; i++) /* use temporary to preserve order */ while (vv.v[i]) { x = vv.v[i]; vv.v[i] = x->next; vec_add(&tv, x); } while (tv.v[i]) { x = tv.v[i]; tv.v[i] = x->next; h = x->hash % n; x->next = v[h]; v[h] = x; } FREE(vv.v); } } static D_SymHash * new_D_SymHash() { D_SymHash *sh = MALLOC(sizeof(D_SymHash)); memset(sh, 0, sizeof(D_SymHash)); sh->grow = INITIAL_SYMHASH_SIZE * 2 + 1; sh->syms.n = INITIAL_SYMHASH_SIZE; sh->syms.v = MALLOC(sh->syms.n * sizeof(void *)); memset(sh->syms.v, 0, sh->syms.n * sizeof(void *)); return sh; } static void free_D_SymHash(D_SymHash *sh) { int i; D_Sym *sym; for (i = 0; i < sh->syms.n; i++) for (; sh->syms.v[i]; sh->syms.v[i] = sym) { sym = sh->syms.v[i]->next; free_D_Sym(sh->syms.v[i]); } FREE(sh->syms.v); FREE(sh); } D_Scope * new_D_Scope(D_Scope *parent) { D_Scope *st = MALLOC(sizeof(D_Scope)); memset(st, 0, sizeof(D_Scope)); if (parent) { st->depth = parent->depth + 1; st->kind = parent->kind; st->search = parent; st->up = parent; st->up_updates = parent; st->down_next = parent->down; parent->down = st; } else st->hash = new_D_SymHash(); return st; } D_Scope * equiv_D_Scope(D_Scope *current) { D_Scope *s = current, *last = current; D_Sym *sy; if (!s) return s; while (s->depth >= current->depth) { if (s->depth == last->depth) { if (current->up == s->up) last = s; else break; } if (s->ll || s->hash) break; if (s->dynamic) break; sy = s->updates; while (sy) { if (sy->scope->depth <= current->depth) break; sy = sy->next; } if (sy) break; if (!s->up_updates) break; s = s->up_updates; } return last; } #if 0 D_Scope * equiv_D_Scope(D_Scope *current) { D_Scope *s = current; while (s) { if (s->ll || s->hash) break; if (s->dynamic) /* conservative */ break; if (s->updates) break; if (!s->search) break; if (s->search->up != current->up) break; if (s->search->up_updates != current->up_updates) break; s = s->search; } return s; } #endif D_Scope * enter_D_Scope(D_Scope *current, D_Scope *scope) { D_Scope *st = MALLOC(sizeof(D_Scope)), *parent = scope->up; memset(st, 0, sizeof(D_Scope)); st->depth = scope->depth; st->up = parent; st->kind = scope->kind; st->search = scope; #if 0 /* clear old updates */ { D_Scope *update_scope = current; while (update_scope) { D_Sym *sy = update_scope->updates; while (sy) { if (sy->scope->depth <= current->depth) goto Lfound; sy = sy->next; } update_scope = update_scope->up_updates; } Lfound: st->up_updates = update_scope; } #else st->up_updates = current; #endif st->down_next = current->down; current->down = st; return st; } D_Scope * global_D_Scope(D_Scope *current) { D_Scope *g = current; while (g->up) g = g->search; return enter_D_Scope(current, g); } D_Scope * scope_D_Scope(D_Scope *current, D_Scope *scope) { D_Scope *st = MALLOC(sizeof(D_Scope)), *parent = current->up; memset(st, 0, sizeof(D_Scope)); st->depth = current->depth; st->up = parent; st->kind = current->kind; st->search = current; st->dynamic = scope; st->up_updates = current; st->down_next = current->down; current->down = st; return st; } void free_D_Scope(D_Scope *st, int force) { D_Scope *s; D_Sym *sym; for (; st->down; st->down = s) { s = st->down->down_next; free_D_Scope(st->down, 0); } if (st->owned_by_user && !force) return; if (st->hash) free_D_SymHash(st->hash); else for (; st->ll; st->ll = sym) { sym = st->ll->next; free_D_Sym(st->ll); } for (; st->updates; st->updates = sym) { sym = st->updates->next; free_D_Sym(st->updates); } FREE(st); } static void commit_ll(D_Scope *st, D_SymHash *sh) { D_Sym *sym; if (st->search) { commit_ll(st->search, sh); for (; st->ll; st->ll = sym) { sym = st->ll->next; symhash_add(sh, st->ll); } } } /* make direct links to the latest update */ static void commit_update(D_Scope *st, D_SymHash *sh) { int i; D_Sym *s; for (i = 0; i < sh->syms.n; i++) for (s = sh->syms.v[i]; s; s = s->next) s->update_of = current_D_Sym(st, s); } /* currently only commit the top level scope */ D_Scope * commit_D_Scope(D_Scope *st) { D_Scope *x = st; if (st->up) return st; while (x->search) x = x->search; commit_ll(st, x->hash); commit_update(st, x->hash); return x; } D_Sym * new_D_Sym(D_Scope *st, char *name, char *end, int sizeof_D_Sym) { int len = end ? end - name : name ? strlen(name) : 0; D_Sym *s = MALLOC(sizeof_D_Sym); memset(s, 0, sizeof_D_Sym); s->name = name; s->len = len; s->hash = strhashl(name, len); s->scope = st; if (st) { if (st->hash) { symhash_add(st->hash, s); } else { s->next = st->ll; st->ll = s; } } return s; } void free_D_Sym(D_Sym *s) { FREE(s); } D_Sym * current_D_Sym(D_Scope *st, D_Sym *sym) { D_Scope *sc; D_Sym *uu; if (sym->update_of) sym = sym->update_of; /* return the last update */ for (sc = st; sc; sc = sc->up_updates) { for (uu = sc->updates; uu; uu = uu->next) if (uu->update_of == sym) return uu; } return sym; } static D_Sym * find_D_Sym_in_Scope_internal(D_Scope *st, char *name, int len, uint h) { D_Sym *ll; for (;st ; st = st->search) { if (st->hash) ll = st->hash->syms.v[h % st->hash->syms.n]; else ll = st->ll; while (ll) { if (ll->hash == h && ll->len == len && !strncmp(ll->name, name, len)) return ll; ll = ll->next; } if (st->dynamic) if ((ll = find_D_Sym_in_Scope_internal(st->dynamic, name, len, h))) return ll; if (!st->search || st->search->up != st->up) break; } return NULL; } static D_Sym * find_D_Sym_internal(D_Scope *cur, char *name, int len, uint h) { D_Sym *ll; if (!cur) return NULL; if (cur->hash) ll = cur->hash->syms.v[h % cur->hash->syms.n]; else ll = cur->ll; while (ll) { if (ll->hash == h && ll->len == len && !strncmp(ll->name, name, len)) break; ll = ll->next; } if (!ll) { if (cur->dynamic) if ((ll = find_D_Sym_in_Scope_internal(cur->dynamic, name, len, h))) return ll; if (cur->search) return find_D_Sym_internal(cur->search, name, len, h); return ll; } return ll; } D_Sym * find_D_Sym(D_Scope *st, char *name, char *end) { int len = end ? end - name : strlen(name); uint h = strhashl(name, len); D_Sym *s = find_D_Sym_internal(st, name, len, h); if (s) return current_D_Sym(st, s); return NULL; } D_Sym * find_global_D_Sym(D_Scope *st, char *name, char *end) { D_Sym *s; int len = end ? end - name : strlen(name); uint h = strhashl(name, len); D_Scope *cur = st; while (cur->up) cur = cur->search; s = find_D_Sym_internal(cur, name, len, h); if (s) return current_D_Sym(st, s); return NULL; } D_Sym * find_D_Sym_in_Scope(D_Scope *st, D_Scope *cur, char *name, char *end) { int len = end ? end - name : strlen(name); uint h = strhashl(name, len); D_Sym *s = find_D_Sym_in_Scope_internal(cur, name, len, h); if (s) return current_D_Sym(st, s); return NULL; } D_Sym * next_D_Sym_in_Scope(D_Scope **scope, D_Sym **sym) { D_Sym *last_sym = *sym, *ll = last_sym; D_Scope *st = *scope; if (ll) { ll = ll->next; if (ll) goto Lreturn; } for (;st ; st = st->search) { if (st->hash) { int i = last_sym ? ((last_sym->hash + 1) % st->hash->syms.n) : 0; if (!last_sym || i) ll = st->hash->syms.v[i]; } else { if (!last_sym) ll = st->ll; } last_sym = 0; if (ll) goto Lreturn; if (!st->search || st->search->up != st->up) break; } Lreturn: if (ll) *sym = ll; *scope = st; return ll; } D_Sym * update_additional_D_Sym(D_Scope *st, D_Sym *sym, int sizeof_D_Sym) { D_Sym *s; sym = current_D_Sym(st, sym); s = MALLOC(sizeof_D_Sym); memcpy(s, sym, sizeof(D_Sym)); if (sym->update_of) sym = sym->update_of; s->update_of = sym; s->next = st->updates; st->updates = s; return s; } D_Sym * update_D_Sym(D_Sym *sym, D_Scope **pst, int sizeof_D_Sym) { *pst = enter_D_Scope(*pst, *pst); return update_additional_D_Sym(*pst, sym, sizeof_D_Sym); } void print_sym(D_Sym *s) { char *c = (char*)MALLOC(s->len + 1); if (s->len) memcpy(c, s->name, s->len); c[s->len] = 0; printf("%s, ", c); FREE(c); } void print_scope(D_Scope *st) { printf("SCOPE %p: ", st); printf(" owned: %d, kind: %d, ", st->owned_by_user, st->kind); if (st->ll) printf(" LL\n"); if (st->hash) printf(" HASH\n"); if (st->hash) { int i; for (i = 0; i < st->hash->syms.n; i++) if (st->hash->syms.v[i]) print_sym(st->hash->syms.v[i]); } else { D_Sym *ll = st->ll; while (ll) { print_sym(ll); ll = ll->next; } } printf("\n\n"); if (st->dynamic) print_scope(st->dynamic); if (st->search) print_scope(st->search); } mcrl2-201210.1/3rd-party/dparser/arg.h000775 001751 001751 00000001354 12042421220 020331 0ustar00jenkinsjenkins000000 000000 /* Copyright 1994-2004 John Plevyak, All Rights Reserved */ #include #include #include #ifndef __alpha #define atoll atol #endif /* Argument Handling */ struct ArgumentState; typedef void ArgumentFunction(struct ArgumentState *arg_state, char *arg); typedef struct { char *name; char key; char *description; char *type; void *location; char *env; ArgumentFunction *pfn; } ArgumentDescription; typedef struct ArgumentState { char **file_argument; int nfile_arguments; char *program_name; ArgumentDescription *desc; } ArgumentState; void usage(ArgumentState *arg_state, char *arg_unused); void process_args(ArgumentState *arg_state, char **argv); void free_args(ArgumentState *arg_state); mcrl2-201210.1/3rd-party/dparser/gram.c000775 001751 001751 00000131761 12042421220 020507 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ #include "gramgram.h" #include "d.h" extern D_ParserTables parser_tables_dparser_gram; static char *action_types[] = { "ACCEPT", "SHIFT", "REDUCE" }; static void print_state(State *s); Production * new_production(Grammar *g, char *name) { Production *p; if ((p = lookup_production(g, name, strlen(name)))) { FREE(name); return p; } p = MALLOC(sizeof(Production)); memset(p, 0, sizeof(Production)); vec_add(&g->productions, p); p->name = name; p->name_len = strlen(name); return p; } static Elem * new_elem() { Elem *e = MALLOC(sizeof(Elem)); memset(e, 0, sizeof(Elem)); return e; } Rule * new_rule(Grammar *g, Production *p) { Rule *r = MALLOC(sizeof(Rule)); memset(r, 0, sizeof(Rule)); r->prod = p; r->end = new_elem(); r->end->kind = ELEM_END; r->end->rule = r; r->action_index = g->action_index; return r; } static Term * new_term() { Term *term = MALLOC(sizeof(Term)); memset(term, 0, sizeof(Term)); return term; } static Elem * new_elem_term(Term *t, Rule *r) { Elem *e = new_elem(); e->kind = ELEM_TERM; e->e.term = t; e->rule = r; vec_add(&r->elems, e); return e; } Elem * new_elem_nterm(Production *p, Rule *r) { Elem *e = new_elem(); e->kind = ELEM_NTERM; e->e.nterm = p; e->rule = r; return e; } static Elem * new_term_string(Grammar *g, char *s, char *e, Rule *r) { Term *t = new_term(); Elem *elem; t->string = MALLOC(e - s + 1); memcpy(t->string, s, e - s); t->string[e - s] = 0; t->string_len = e - s; vec_add(&g->terminals, t); elem = new_elem_term(t, r); return elem; } #define ESC(_c) *ss++ = '\\'; *ss++ = _c; break; char * escape_string_for_regex(const char *s) { char *ss = (char*)MALLOC((strlen(s) + 1) * 2), *sss = ss; for (; *s; s++) { switch (*s) { case '(': case ')': case '[': case ']': case '-': case '^': case '*': case '?': case '+': *ss++ = '\\'; /* fall through */ default: *ss++ = *s; break; } } *ss = 0; return sss; } static void unescape_term_string(Term *t) { char *s, *start = 0, *ss; int length, base = 0; for (ss = s = t->string; *s; s++) { if (*s == '\\') { switch (s[1]) { case 'b': *ss = '\b'; s++; break; case 'f': *ss = '\f'; s++; break; case 'n': *ss = '\n'; s++; break; case 'r': *ss = '\r'; s++; break; case 't': *ss = '\t'; s++; break; case 'v': *ss = '\v'; s++; break; case 'a': *ss = '\a'; s++; break; case 'c': *ss = 0; return; case '\"': if (t->kind == TERM_REGEX) { *ss = '\"'; s++; break; } else goto Ldefault; case '\'': if (t->kind == TERM_STRING) { *ss = '\''; s++; break; } else goto Ldefault; case 'x': length = 0; if (isxdigit_(s[2])) { base = 16; start = s + 2; length++; if (isxdigit_(s[3])) length++; } s += length + 1; goto Lncont; case 'd': length = 0; if (isdigit_(s[2])) { base = 10; start = s + 2; length++; if (isdigit_(s[3])) { length++; if (isdigit_(s[4]) && ((s[2] < '2') || ((s[2] == '2') && ((s[3] < '5') || ((s[3] == '5') && (s[4] < '6')))))) length++; } } s += length + 1; goto Lncont; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': length = 1; base = 8; start = s + 1; if (isdigit_(s[2]) && (s[2] != '8') && (s[2] != '9')) { length++; if (isdigit_(s[3]) && (s[3] != '8') && (s[3] != '9')) { length++; } } s += length; /* fall through */ Lncont: if (length > 0) { char saved_c = start[length]; start[length] = '\0'; *ss = (unsigned char) strtol(start, NULL, base); start[length] = saved_c; if (*s > 0) break; d_fail("encountered an escaped NULL while processing '%s'", t->string); } else goto next; Ldefault: default: *ss++ = *s; *ss = s[1]; s++; break; } } else *ss = *s; ss++; next:; } *ss = 0; t->string_len = strlen(t->string); if (!t->string_len) d_fail("empty string after unescape '%s'", t->string); } Elem * new_string(Grammar *g, char *s, char *e, Rule *r) { Elem *x = new_term_string(g, s + 1, e - 1, r); x->e.term->kind = (*s == '"') ? TERM_REGEX : TERM_STRING; unescape_term_string(x->e.term); return x; } Elem * new_utf8_char(Grammar *g, char *s, char *e, Rule *r) { char utf8_code [4]; unsigned long utf32_code, base, len = 0; Elem *x; for (utf32_code=0, base=1; e>=s+3; base*=16) { e--; if (*e >= '0' && *e <= '9') utf32_code += base * (*e - '0'); else if (*e >= 'a' && *e <= 'f') utf32_code += base * (*e - 'a' + 10); else if (*e >= 'A' && *e <= 'F') utf32_code += base * (*e - 'A' + 10); } if (utf32_code < 0x80) { utf8_code[0] = utf32_code; len = 1; } else if (utf32_code < 0x800) { utf8_code[0] = 0xc0 | ((utf32_code >> 6) & 0x1f); utf8_code[1] = 0x80 | (utf32_code & 0x3f); len = 2; } else if (utf32_code < 0x10000) { utf8_code[0] = 0xe0 | ((utf32_code >> 12) & 0x0f); utf8_code[1] = 0x80 | ((utf32_code >> 6) & 0x3f); utf8_code[2] = 0x80 | (utf32_code & 0x3f); len = 3; } else if (utf32_code < 0x02000000) { utf8_code[0] = 0xf0 | ((utf32_code >> 18) & 0x07); utf8_code[1] = 0x80 | ((utf32_code >> 12) & 0x3f); utf8_code[2] = 0x80 | ((utf32_code >> 6) & 0x3f); utf8_code[3] = 0x80 | (utf32_code & 0x3f); len = 4; } else { d_fail("UTF32 Unicode value U+%8X too large for valid UTF-8 encoding (cf. Unicode Spec 4.0, section 3.9)", utf32_code); } x = new_term_string(g, utf8_code, utf8_code + len, r); x->e.term->kind = TERM_STRING; return x; } Elem * new_ident(char *s, char *e, Rule *r) { Elem *x = new_elem(); x->kind = ELEM_UNRESOLVED; x->e.unresolved.string = dup_str(s, e); x->e.unresolved.len = strlen(x->e.unresolved.string); x->rule = r; if (r) vec_add(&r->elems, x); return x; } void new_token(Grammar *g, char *s, char *e) { Term *t = new_term(); t->string = MALLOC(e - s + 1); memcpy(t->string, s, e - s); t->string[e - s] = 0; t->string_len = e - s; vec_add(&g->terminals, t); t->kind = TERM_TOKEN; } Elem * new_code(Grammar *g, char *s, char *e, Rule *r) { Elem *x = new_term_string(g, s, e, r); x->e.term->kind = TERM_CODE; return x; } Elem * dup_elem(Elem *e, Rule *r) { Elem *ee = MALLOC(sizeof(Elem)); memcpy(ee, e, sizeof(Elem)); if (ee->kind == ELEM_UNRESOLVED) ee->e.unresolved.string = dup_str(e->e.unresolved.string, 0); ee->rule = r; return ee; } void add_global_code(Grammar *g, char *start, char *end, int line) { if (!g->code) g->code = MALLOC(sizeof(Code) * 4); else if (!((g->ncode + 1) & 4)) g->code = REALLOC(g->code, sizeof(Code) * (g->ncode + 4)); g->code[g->ncode].code = dup_str(start, end); g->code[g->ncode].line = line; g->ncode++; } void new_declaration(Grammar *g, Elem *e, uint kind) { Declaration *d = MALLOC(sizeof(*d)); d->elem = e; d->kind = kind; d->index = g->declarations.n; vec_add(&g->declarations, d); } void add_declaration(Grammar *g, char *start, char *end, uint kind, uint line) { if (start == end) { switch (kind) { case DECLARE_SET_OP_PRIORITY: g->set_op_priority_from_rule = 1; return; case DECLARE_STATES_FOR_ALL_NTERMS: g->states_for_all_nterms = 1; return; case DECLARE_LONGEST_MATCH: g->longest_match = 1; break; case DECLARE_ALL_MATCHES: g->longest_match = 0; break; case DECLARE_TOKENIZE: g->tokenizer = 1; break; case DECLARE_SAVE_PARSE_TREE: g->save_parse_tree = 1; return; default: d_fail("declare expects argument, line %d", line); } } switch (kind) { case DECLARE_WHITESPACE: g->default_white_space = dup_str(start, end); return; case DECLARE_SET_OP_PRIORITY: d_fail("declare does not expect argument, line %d", line); default: new_declaration(g, new_ident(start, end, NULL), kind); break; } } D_Pass * find_pass(Grammar *g, char *start, char *end) { int i, l; while (*start && isspace_(*start)) start++; l = end - start; for (i = 0; i < g->passes.n; i++) if (l == g->passes.v[i]->name_len && !strncmp(g->passes.v[i]->name, start, l)) return g->passes.v[i]; return NULL; } void add_pass(Grammar *g, char *start, char *end, uint kind, uint line) { if (find_pass(g, start, end)) d_fail("duplicate pass '%s' line %d", dup_str(start, end), line); else { D_Pass *p = MALLOC(sizeof(*p)); p->name = dup_str(start, end); p->name_len = end - start; p->kind = kind; p->index = g->pass_index++; vec_add(&g->passes, p); } } void add_pass_code(Grammar *g, Rule *r, char *pass_start, char *pass_end, char *code_start, char *code_end, uint pass_line, uint code_line) { D_Pass *p = find_pass(g, pass_start, pass_end); if (!p) d_fail("unknown pass '%s' line %d", dup_str(pass_start, pass_end), pass_line); while (r->pass_code.n <= p->index) vec_add(&r->pass_code, NULL); r->pass_code.v[p->index] = MALLOC(sizeof(Code)); r->pass_code.v[p->index]->code = dup_str(code_start, code_end); r->pass_code.v[p->index]->line = code_line; } Production * new_internal_production(Grammar *g, Production *p) { char *n = p ? p->name : " _synthetic"; char *name = MALLOC(strlen(n) + 21); Production *pp = NULL, *tp = NULL, *ttp; int i, found = 0; sprintf(name, "%s__%d", n, g->productions.n); pp = new_production(g, name); pp->internal = INTERNAL_HIDDEN; pp->regex = p ? p->regex : 0; if (p) { for (i = 0; i < g->productions.n; i++) { if (found) { ttp = g->productions.v[i]; g->productions.v[i] = tp; tp = ttp; } else if (p == g->productions.v[i]) { found = 1; tp = g->productions.v[i+1]; g->productions.v[i+1] = pp; i++; } } } return pp; } void conditional_EBNF(Grammar *g) { Production *pp; Rule *rr; pp = new_internal_production(g, g->p); pp->internal = INTERNAL_CONDITIONAL; rr = new_rule(g, pp); vec_add(&rr->elems, last_elem(g->r)); last_elem(g->r)->rule = rr; rr->elems.v[rr->elems.n - 1]->rule = rr; vec_add(&pp->rules, rr); vec_add(&pp->rules, new_rule(g, pp)); last_elem(g->r) = new_elem_nterm(pp, g->r); } void star_EBNF(Grammar *g) { Production *pp; Rule *rr; pp = new_internal_production(g, g->p); pp->internal = INTERNAL_STAR; rr = new_rule(g, pp); if (!g->right_recursive_BNF) { vec_add(&rr->elems, new_elem_nterm(pp, rr)); vec_add(&rr->elems, last_elem(g->r)); last_elem(g->r) = new_elem_nterm(pp, g->r); last_elem(rr)->rule = rr; } else { vec_add(&rr->elems, last_elem(g->r)); last_elem(g->r) = new_elem_nterm(pp, g->r); last_elem(rr)->rule = rr; vec_add(&rr->elems, new_elem_nterm(pp, rr)); } vec_add(&pp->rules, rr); vec_add(&pp->rules, new_rule(g, pp)); } void plus_EBNF(Grammar *g) { Production *pp; Rule *rr; Elem *elem; pp = new_internal_production(g, g->p); pp->internal = INTERNAL_PLUS; rr = new_rule(g, pp); if (!g->right_recursive_BNF) { elem = last_elem(g->r); vec_add(&rr->elems, new_elem_nterm(pp, rr)); vec_add(&rr->elems, dup_elem(elem, rr)); last_elem(g->r) = new_elem_nterm(pp, g->r); if (g->r->rule_priority) { rr->rule_priority = g->r->rule_priority; rr->rule_assoc = ASSOC_NARY_LEFT; } } else { elem = last_elem(g->r); vec_add(&rr->elems, dup_elem(elem, rr)); last_elem(g->r) = new_elem_nterm(pp, g->r); vec_add(&rr->elems, new_elem_nterm(pp, rr)); if (g->r->rule_priority) { rr->rule_priority = g->r->rule_priority; rr->rule_assoc = ASSOC_NARY_RIGHT; } } vec_add(&pp->rules, rr); rr = new_rule(g, pp); vec_add(&rr->elems, elem); elem->rule = rr; vec_add(&pp->rules, rr); } void rep_EBNF(Grammar *g, int min, int max) { Production *pp; Rule *rr; Elem *elem; int i, j; if (max < min) max = min; pp = new_internal_production(g, g->p); elem = last_elem(g->r); for (i = min; i <= max; i++) { rr = new_rule(g, pp); for (j = 0; j < i; j++) vec_add(&rr->elems, dup_elem(elem, rr)); vec_add(&pp->rules, rr); } last_elem(g->r) = new_elem_nterm(pp, g->r); FREE(elem); } void initialize_productions(Grammar *g) { Production *pp = new_production(g, dup_str("0 Start", 0)); pp->internal = INTERNAL_HIDDEN; } void finish_productions(Grammar *g) { Production *pp = g->productions.v[0]; Rule *rr = new_rule(g, pp); vec_add(&rr->elems, new_elem_nterm(NULL, rr)); vec_add(&pp->rules, rr); rr->elems.v[0]->e.nterm = g->productions.v[1]; } Production * lookup_production(Grammar *g, char *name, int l) { int i; for (i = 0; i < g->productions.n; i++) { Production *pp = g->productions.v[i]; if (pp->name_len != l || strncmp(pp->name, name, l)) continue; return pp; } return NULL; } static Term * lookup_token(Grammar *g, char *name, int l) { int i; for (i = 0; i < g->terminals.n; i++) { Term *t = g->terminals.v[i]; if (t->kind != TERM_TOKEN || t->string_len != l || strncmp(t->string, name, l)) continue; return t; } return NULL; } static Term * unique_term(Grammar *g, Term *t) { int i; for (i = 0; i < g->terminals.n; i++) if (t->kind == g->terminals.v[i]->kind && t->string_len == g->terminals.v[i]->string_len && t->term_priority == g->terminals.v[i]->term_priority && t->term_name == g->terminals.v[i]->term_name && (!g->set_op_priority_from_rule || (t->op_assoc == g->terminals.v[i]->op_assoc && t->op_priority == g->terminals.v[i]->op_priority)) && !strncmp(t->string, g->terminals.v[i]->string, t->string_len)) return g->terminals.v[i]; return t; } static void compute_nullable(Grammar *g) { int i, j, k, changed = 1; Elem *e; /* ensure that the trivial case is the first cause */ for (i = 0; i < g->productions.n; i++) { for (j = 0; j < g->productions.v[i]->rules.n; j++) if (!g->productions.v[i]->rules.v[j]->elems.n) { g->productions.v[i]->nullable = g->productions.v[i]->rules.v[j]; break; } } /* transitive closure */ while (changed) { changed = 0; for (i = 0; i < g->productions.n; i++) { if (!g->productions.v[i]->nullable) for (j = 0; j < g->productions.v[i]->rules.n; j++) { for (k = 0; k < g->productions.v[i]->rules.v[j]->elems.n; k++) { e = g->productions.v[i]->rules.v[j]->elems.v[k]; if (e->kind != ELEM_NTERM || !e->e.nterm->nullable) goto Lnot_nullable; } changed = 1; g->productions.v[i]->nullable = g->productions.v[i]->rules.v[j]; break; } Lnot_nullable:; } } } /* verify and cleanup the grammar datastructures - resolve non-terminals - set element indexes */ static void resolve_grammar(Grammar *g) { int i, j, k, l; Production *p, *pp; Rule *r; Elem *e; Term *last_term, *t; g->rule_index = 0; for (i = 0; i < g->productions.n; i++) { p = g->productions.v[i]; if (p != lookup_production(g, p->name, p->name_len)) d_fail("duplicate production '%s'", p->name); p->index = i; for (j = 0; j < p->rules.n; j++) { r = p->rules.v[j]; r->index = g->rule_index++; last_term = NULL; for (k = 0; k < r->elems.n; k++) { e = r->elems.v[k]; e->index = k; if (e->kind == ELEM_UNRESOLVED) { l = e->e.unresolved.len; if ((pp = lookup_production(g, e->e.unresolved.string, l))) { FREE(e->e.unresolved.string); e->e.unresolved.string = 0; e->kind = ELEM_NTERM; e->e.nterm = pp; } else if ((t = lookup_token(g, e->e.unresolved.string, l))) { FREE(e->e.unresolved.string); e->e.unresolved.string = 0; e->kind = ELEM_TERM; e->e.term = t; } else { char str[256]; strncpy(str, e->e.unresolved.string, l); str[l < 255 ? l : 255] = 0; d_fail("unresolved identifier: '%s'", str); } } if (e->kind == ELEM_TERM) last_term = e->e.term; } r->end->index = r->elems.n; if (g->set_op_priority_from_rule) { if (last_term && r->rule_assoc) { last_term->op_assoc = r->rule_assoc; last_term->op_priority = r->rule_priority; } } } } for (i = 0; i < g->terminals.n; i++) g->terminals.v[i]->index = i; compute_nullable(g); } static void merge_identical_terminals(Grammar *g) { int i, j, k; Production *p; Rule *r; Elem *e; for (i = 0; i < g->productions.n; i++) { p = g->productions.v[i]; for (j = 0; j < p->rules.n; j++) { r = p->rules.v[j]; for (k = 0; k < r->elems.n; k++) { e = r->elems.v[k]; if (e->kind == ELEM_TERM) e->e.term = unique_term(g, e->e.term); } } } } void print_term(Term *t) { char *s = t->string ? escape_string(t->string) : NULL; if (t->term_name) printf("term_name(\"%s\") ", t->term_name); else if (t->kind == TERM_STRING) { if (!t->string || !*t->string) printf(" "); else printf("string(\"%s\") ", s); } else if (t->kind == TERM_REGEX) { printf("regex(\"%s\") ", s); } else if (t->kind == TERM_CODE) printf("code(\"%s\") ", s); else if (t->kind == TERM_TOKEN) printf("token(\"%s\") ", s); else d_fail("unknown token kind"); if (s) FREE(s); } void print_elem(Elem *ee) { if (ee->kind == ELEM_TERM) print_term(ee->e.term); else if (ee->kind == ELEM_UNRESOLVED) printf("%s ", ee->e.unresolved.string); else printf("%s ", ee->e.nterm->name); } struct EnumStr { uint e; char *s; } assoc_strings[] = { { ASSOC_NONE, "$none" }, { ASSOC_NARY_LEFT, "$left" }, { ASSOC_NARY_RIGHT, "$right" }, { ASSOC_UNARY_LEFT, "$unary_left" }, { ASSOC_UNARY_RIGHT, "$unary_right" }, { ASSOC_BINARY_LEFT, "$binary_left" }, { ASSOC_BINARY_RIGHT, "$binary_right" }, { ASSOC_NO, "$noassoc" } }; static char * assoc_str(uint e) { int i; for (i = 0; i < sizeof(assoc_strings) / sizeof(assoc_strings[0]); i++) if (e == assoc_strings[i].e) return assoc_strings[i].s; return assoc_strings[0].s; } void print_rule(Rule *r) { int k; printf("%s: ", r->prod->name); for (k = 0; k < r->elems.n; k++) print_elem(r->elems.v[k]); if (r->speculative_code.code) printf("SPECULATIVE_CODE\n%s\nEND CODE\n", r->speculative_code.code); if (r->final_code.code) printf("FINAL_CODE\n%s\nEND CODE\n", r->final_code.code); } void print_grammar(Grammar *g) { uint i, j, k; Production *pp; Rule *rr; if (!g->productions.n) return; printf("PRODUCTIONS\n\n"); for (i = 0; i < g->productions.n; i++) { pp = g->productions.v[i]; printf("%s (%d)\n", pp->name, i); for (j = 0; j < pp->rules.n; j++) { rr = pp->rules.v[j]; if (!j) printf("\t: "); else printf("\t| "); for (k = 0; k < rr->elems.n; k++) print_elem(rr->elems.v[k]); if (rr->op_priority) printf("op %d ", rr->op_priority); if (rr->op_assoc) printf("%s ", assoc_str(rr->op_assoc)); if (rr->rule_priority) printf("rule %d ", rr->rule_priority); if (rr->rule_assoc) printf("%s ", assoc_str(rr->rule_assoc)); if (rr->speculative_code.code) printf("%s ", rr->speculative_code.code); if (rr->final_code.code) printf("%s ", rr->final_code.code); printf("\n"); } printf("\t;\n"); printf("\n"); } printf("TERMINALS\n\n"); for (i = 0; i < g->terminals.n; i++) { printf("\t"); print_term(g->terminals.v[i]); printf("(%d)\n", i + g->productions.n); } printf("\n"); } static void print_item(Item *i) { int j, end = 1; printf("\t%s: ", i->rule->prod->name); for (j = 0; j < i->rule->elems.n; j++) { Elem *e = i->rule->elems.v[j]; if (i == e) { printf(". "); end = 0; } print_elem(e); } if (end) printf(". "); printf("\n"); } static void print_conflict(char *kind, int *conflict) { if (!*conflict) { printf(" CONFLICT (before precedence and associativity)\n"); *conflict = 1; } printf("\t%s conflict ", kind); printf("\n"); } static void print_state(State *s) { int j, conflict = 0; printf("STATE %d (%d ITEMS)%s\n", s->index, s->items.n, s->accept ? " ACCEPT" : ""); for (j = 0; j < s->items.n; j++) print_item(s->items.v[j]); if (s->gotos.n) printf(" GOTO\n"); for (j = 0; j < s->gotos.n; j++) { printf("\t"); print_elem(s->gotos.v[j]->elem); printf(" : %d\n", s->gotos.v[j]->state->index); } printf(" ACTION\n"); for (j = 0; j < s->reduce_actions.n; j++) { Action *a = s->reduce_actions.v[j]; printf("\t%s\t", action_types[a->kind]); print_rule(a->rule); printf("\n"); } for (j = 0; j < s->shift_actions.n; j++) { Action *a = s->shift_actions.v[j]; printf("\t%s\t", action_types[a->kind]); if (a->kind == ACTION_SHIFT) { print_term(a->term); printf("%d", a->state->index); } printf("\n"); } if (s->reduce_actions.n > 1) print_conflict("reduce/reduce", &conflict); if (s->reduce_actions.n && s->shift_actions.n) print_conflict("shift/reduce", &conflict); printf("\n"); } void print_states(Grammar *g) { int i; for (i = 0; i < g->states.n; i++) print_state(g->states.v[i]); } int state_for_declaration(Grammar *g, int iproduction) { int i; for (i = 0; i < g->declarations.n; i++) if (g->declarations.v[i]->kind == DECLARE_STATE_FOR && g->declarations.v[i]->elem->e.nterm->index == iproduction) return 1; return 0; } static void make_elems_for_productions(Grammar *g) { int i, j, k, l; Rule *rr; Production *pp, *ppp; pp = g->productions.v[0]; for (i = 0; i < g->productions.n; i++) if (!g->productions.v[i]->internal) { if (g->states_for_all_nterms || state_for_declaration(g, i)) { /* try to find an existing elem */ for (j = 0; j < g->productions.n; j++) for (k = 0; k < g->productions.v[j]->rules.n; k++) { rr = g->productions.v[j]->rules.v[k]; for (l = 0; l < rr->elems.n; l++) if (rr->elems.v[l]->e.term_or_nterm == g->productions.v[i]) { g->productions.v[i]->elem = rr->elems.v[l]; break; } } if (j >= g->productions.n) { /* not found */ g->productions.v[i]->elem = new_elem_nterm(g->productions.v[i], new_rule(g, pp)); g->productions.v[i]->elem->rule->index = g->rule_index++; /* fake */ } } } if (!g->states_for_all_nterms && g->states_for_whitespace && (ppp = lookup_production(g, "whitespace", sizeof("whitespace")-1))) { ppp->elem = new_elem_nterm(ppp, new_rule(g, pp)); ppp->elem->rule->index = g->rule_index++; /* fake */ } } static void convert_regex_production_one(Grammar *g, Production *p) { int j, k, l; Production *pp; Rule *r, *rr; Elem *e; Term *t; int circular = 0; char *buf = 0, *b, *s; int buf_len = 0; if (p->regex_term) /* already done */ return; if (p->in_regex) d_fail("circular regex production '%s'", p->name); p->in_regex = 1; for (j = 0; j < p->rules.n; j++) { r = p->rules.v[j]; if (r->final_code.code || (r->speculative_code.code && p->rules.n > 1)) d_fail("final and/or multi-rule code not permitted in regex productions '%s'", p->name); for (k = 0; k < r->elems.n; k++) { e = r->elems.v[k]; if (e->kind == ELEM_NTERM) { if (!e->e.nterm->regex) d_fail("regex production '%s' cannot invoke non-regex production '%s'", p->name, e->e.nterm->name); pp = e->e.nterm; for (l = 0; l < pp->rules.n; l++) if (pp->rules.v[l]->speculative_code.code || pp->rules.v[l]->final_code.code) d_fail("code not permitted in rule %d of regex productions '%s'", l, p->name); if (p != pp) { convert_regex_production_one(g, pp); buf_len += pp->regex_term->string_len + 5; } else { circular = 1; buf_len += 5; } } else { /* e->kind == ELEM_TERM */ if (e->e.term->kind == TERM_CODE || e->e.term->kind == TERM_TOKEN) d_fail("regex production '%s' cannot include scanners or tokens"); buf_len += e->e.term->string_len + 5; } } } b = buf = (char*)MALLOC(buf_len + 1); t = new_term(); t->kind = TERM_REGEX; t->string = buf; t->index = g->terminals.n; t->regex_production = p; vec_add(&g->terminals, t); p->regex_term = t; p->regex_term->term_name = dup_str(p->name, 0); if (circular) { /* attempt to match to regex operators */ if (p->rules.n != 2) Lfail: d_fail("unable to resolve circular regex production: '%s'", p->name); l = p->rules.v[0]->elems.n + p->rules.v[1]->elems.n; if (l == 2 || l == 3) { if (p->rules.v[0]->elems.n != 2 && p->rules.v[1]->elems.n != 2) goto Lfail; r = p->rules.v[0]->elems.n == 2 ? p->rules.v[0] : p->rules.v[1]; rr = p->rules.v[0] == r ? p->rules.v[1] : p->rules.v[0]; if (r->elems.v[0]->e.nterm != p && r->elems.v[1]->e.nterm != p) goto Lfail; e = r->elems.v[0]->e.nterm == p ? r->elems.v[1] : r->elems.v[1]; if (rr->elems.n && e->e.term_or_nterm != rr->elems.v[0]->e.term_or_nterm) goto Lfail; t = e->kind == ELEM_TERM ? e->e.term : e->e.nterm->regex_term; *b++ = '('; if (t->kind == TERM_STRING) s = escape_string_for_regex(t->string); else s = t->string; memcpy(b, s, strlen(s)); b += strlen(s); if (t->kind == TERM_STRING) FREE(s); *b++ = ')'; if (l == 2) *b++ = '*'; else *b++ = '+'; *b = 0; p->regex_term->string_len = strlen(p->regex_term->string); } else goto Lfail; } else { /* handle the base case, p = (r | r'), r = (e e') */ if (p->rules.n > 1) *b++ = '('; for (j = 0; j < p->rules.n; j++) { r = p->rules.v[j]; if (r->elems.n > 1) *b++ = '('; for (k = 0; k < r->elems.n; k++) { e = r->elems.v[k]; t = e->kind == ELEM_TERM ? e->e.term : e->e.nterm->regex_term; if (t->kind == TERM_STRING) s = escape_string_for_regex(t->string); else s = t->string; memcpy(b, s, strlen(s)); b += strlen(s); if (t->kind == TERM_STRING) FREE(s); } if (r->elems.n > 1) *b++ = ')'; if (j != p->rules.n - 1) *b++ = '|'; } if (p->rules.n > 1) *b++ = ')'; *b = 0; p->regex_term->string_len = strlen(p->regex_term->string); } p->in_regex = 0; } static void convert_regex_productions(Grammar *g) { int i, j, k; Production *p; Rule *r; for (i = 0; i < g->productions.n; i++) { p = g->productions.v[i]; if (!p->regex) continue; convert_regex_production_one(g, p); } for (i = 0; i < g->productions.n; i++) { p = g->productions.v[i]; for (j = 0; j < p->rules.n; j++) { r = p->rules.v[j]; for (k = 0; k < r->elems.n; k++) { if (r->elems.v[k]->kind == ELEM_NTERM && r->elems.v[k]->e.nterm->regex_term) { r->elems.v[k]->e.term = r->elems.v[k]->e.nterm->regex_term; r->elems.v[k]->kind = ELEM_TERM; } } } } } static void check_default_actions(Grammar *g) { Production *pdefault; pdefault = lookup_production(g, "_", 1); if (pdefault && pdefault->rules.n > 1) d_fail("number of rules in default action != 1"); } typedef struct { struct State *eq; struct Rule *diff_rule; struct State *diff_state; } EqState; void build_eq(Grammar *g) { int i, j, k, changed = 1, x, xx; State *s, *ss; EqState *eq, *e, *ee; eq = (EqState*)MALLOC(sizeof(EqState)*g->states.n); memset(eq, 0, sizeof(EqState)*g->states.n); while (changed) { changed = 0; for (i = 0; i < g->states.n; i++) { s = g->states.v[i]; e = &eq[s->index]; for (j = i + 1; j < g->states.n; j++) { ss = g->states.v[j]; ee = &eq[ss->index]; if (e->eq || ee->eq) continue; if (s->same_shifts != ss->same_shifts && ss->same_shifts != s) continue; /* check gotos */ if (s->gotos.n != ss->gotos.n) continue; for (k = 0; k < s->gotos.n; k++) { if (elem_symbol(g, s->gotos.v[k]->elem) != elem_symbol(g, ss->gotos.v[k]->elem)) goto Lcontinue; if (s->gotos.v[k]->state != ss->gotos.v[k]->state) { EqState *ge = &eq[s->gotos.v[k]->state->index]; EqState *gee = &eq[ss->gotos.v[k]->state->index]; if (ge->eq != ss->gotos.v[k]->state && gee->eq != s->gotos.v[k]->state) goto Lcontinue; if ((ee->diff_state && ee->diff_state != eq[ss->gotos.v[k]->state->index].eq) || (e->diff_state && e->diff_state != eq[s->gotos.v[k]->state->index].eq)) goto Lcontinue; /* allow one different state */ ee->diff_state = ss->gotos.v[k]->state; e->diff_state = s->gotos.v[k]->state; } } /* check reductions */ if (s->reduce_actions.n != ss->reduce_actions.n) continue; for (k = 0; k < s->reduce_actions.n; k++) { if (s->reduce_actions.v[k]->rule == ss->reduce_actions.v[k]->rule) continue; if (s->reduce_actions.v[k]->rule->prod != ss->reduce_actions.v[k]->rule->prod) goto Lcontinue; if ((x = s->reduce_actions.v[k]->rule->elems.n) != (xx = ss->reduce_actions.v[k]->rule->elems.n)) { if ((ee->diff_rule && ee->diff_rule != ss->reduce_actions.v[k]->rule) || (e->diff_rule && e->diff_rule != s->reduce_actions.v[k]->rule)) goto Lcontinue; /* allow one different rule */ ee->diff_rule = ss->reduce_actions.v[k]->rule; e->diff_rule = s->reduce_actions.v[k]->rule; } } ee->eq = s; changed = 1; Lcontinue:; } } } for (i = 0; i < g->states.n; i++) { s = g->states.v[i]; e = &eq[s->index]; if (e->eq) { if (d_verbose_level > 2) { printf("eq %d %d ", s->index, e->eq->index); if (e->diff_state) printf("diff state (%d %d) ", e->diff_state->index, eq[e->eq->index].diff_state->index); if (e->diff_rule) { printf("diff rule "); printf("[ "); print_rule(e->diff_rule); printf("][ "); print_rule(eq[e->eq->index].diff_rule); printf("]"); } printf("\n"); } } } for (i = 0; i < g->states.n; i++) { s = g->states.v[i]; e = &eq[s->index]; if (e->eq && e->diff_state) { if (eq[e->diff_state->index].diff_rule && eq[e->diff_state->index].diff_rule->elems.n == 2) { s->reduces_to = e->eq; s->reduces_with = eq[e->eq->index].diff_rule; s->reduces_to_then_with = e->diff_rule; } else if (eq[eq[e->eq->index].diff_state->index].diff_rule && eq[eq[e->eq->index].diff_state->index].diff_rule->elems.n == 2) { e->eq->reduces_to = s; s->reduces_with = e->diff_rule; s->reduces_to_then_with = eq[e->eq->index].diff_rule; } } } for (i = 0; i < g->states.n; i++) { s = g->states.v[i]; if (s->reduces_to) if (d_verbose_level) printf("reduces_to %d %d\n", s->index, s->reduces_to->index); } FREE(eq); } Grammar * new_D_Grammar(char *pathname) { Grammar *g = (Grammar *)MALLOC(sizeof(Grammar)); memset(g, 0, sizeof(Grammar)); g->pathname = dup_str(pathname, pathname + strlen(pathname)); return g; } static void free_rule(Rule *r) { int i; FREE(r->end); if (r->final_code.code) FREE(r->final_code.code); if (r->speculative_code.code) FREE(r->speculative_code.code); vec_free(&r->elems); for (i = 0; i < r->pass_code.n; i++) { FREE(r->pass_code.v[i]->code); FREE(r->pass_code.v[i]); } vec_free(&r->pass_code); FREE(r); } void free_D_Grammar(Grammar *g) { int i, j, k; for (i = 0; i < g->productions.n; i++) { Production *p = g->productions.v[i]; for (j = 0; j < p->rules.n; j++) { Rule *r = p->rules.v[j]; if (r == g->r) g->r = 0; for (k = 0; k < r->elems.n; k++) { Elem *e = r->elems.v[k]; if (e == p->elem) p->elem = 0; FREE(e); } if (r->end == p->elem) p->elem = 0; free_rule(r); } vec_free(&p->rules); FREE(p->name); if (p->elem) { free_rule(p->elem->rule); FREE(p->elem); } FREE(p); } vec_free(&g->productions); for (i = 0; i < g->terminals.n; i++) { Term *t = g->terminals.v[i]; if (t->string) FREE(t->string); if (t->term_name) FREE(t->term_name); FREE(t); } vec_free(&g->terminals); for (i = 0; i < g->actions.n; i++) free_Action(g->actions.v[i]); vec_free(&g->actions); if (g->scanner.code) FREE(g->scanner.code); for (i = 0; i < g->states.n; i++) { State *s = g->states.v[i]; vec_free(&s->items); vec_free(&s->items_hash); for (j = 0; j < s->gotos.n; j++) { FREE(s->gotos.v[j]->elem); FREE(s->gotos.v[j]); } vec_free(&s->gotos); vec_free(&s->shift_actions); vec_free(&s->reduce_actions); for (j = 0; j < s->right_epsilon_hints.n; j++) FREE(s->right_epsilon_hints.v[j]); vec_free(&s->right_epsilon_hints); for (j = 0; j < s->error_recovery_hints.n; j++) FREE(s->error_recovery_hints.v[j]); vec_free(&s->error_recovery_hints); if (!s->same_shifts) { for (j = 0; j < s->scanner.states.n; j++) { vec_free(&s->scanner.states.v[j]->accepts); vec_free(&s->scanner.states.v[j]->live); FREE(s->scanner.states.v[j]); } vec_free(&s->scanner.states); for (j = 0; j < s->scanner.transitions.n; j++) if (s->scanner.transitions.v[j]) { vec_free(&s->scanner.transitions.v[j]->live_diff); vec_free(&s->scanner.transitions.v[j]->accepts_diff); FREE(s->scanner.transitions.v[j]); } vec_free(&s->scanner.transitions); } FREE(s->goto_valid); FREE(s); } vec_free(&g->states); for (i = 0; i < g->ncode; i++) FREE(g->code[i].code); FREE(g->code); for (i = 0; i < g->declarations.n; i++) { FREE(g->declarations.v[i]->elem); FREE(g->declarations.v[i]); } vec_free(&g->declarations); for (i = 0; i < g->passes.n; i++) { FREE(g->passes.v[i]->name); FREE(g->passes.v[i]); } vec_free(&g->passes); for (i = 0; i < g->all_pathnames.n; i++) FREE(g->all_pathnames.v[i]); FREE(g->pathname); if (g->default_white_space) FREE(g->default_white_space); FREE(g); } int parse_grammar(Grammar *g, char *pathname, char *sarg) { D_Parser *p; int res = 0; char *s = sarg; vec_add(&g->all_pathnames, dup_str(pathname, 0)); if (!s) if (!(s = sbuf_read(pathname))) return -1; if (!g->productions.n) initialize_productions(g); p = new_D_Parser(&parser_tables_dparser_gram, sizeof(D_ParseNode_User)); p->initial_globals = g; p->loc.pathname = pathname; if (dparse(p, s, strlen(s))) { if (g->productions.n > 1) finish_productions(g); } else res = -1; if (!sarg) FREE(s); free_D_Parser(p); return res; } static int scanner_declaration(Declaration *d) { switch (d->kind) { case DECLARE_TOKENIZE: case DECLARE_LONGEST_MATCH: case DECLARE_ALL_MATCHES: return 1; default: return 0; } } static void set_declaration_group(Production *p, Production *root, Declaration *d) { int i, j; if (p->declaration_group[d->kind] == root) return; if (d->kind == DECLARE_TOKENIZE && p->declaration_group[d->kind]) { d_fail("shared tokenize subtrees"); return; } p->declaration_group[d->kind] = root; p->last_declaration[d->kind] = d; for (i = 0; i < p->rules.n; i++) { for (j = 0; j < p->rules.v[i]->elems.n; j++) if (p->rules.v[i]->elems.v[j]->kind == ELEM_NTERM) set_declaration_group(p->rules.v[i]->elems.v[j]->e.nterm, root, d); } } static void propogate_declarations(Grammar *g) { int i, j, k; Production *p, *start = g->productions.v[0]; Rule *r; Elem *e; /* global defaults */ if (g->tokenizer) new_declaration(g, new_elem_nterm(g->productions.v[0], NULL), DECLARE_TOKENIZE); if (g->longest_match) new_declaration(g, new_elem_nterm(g->productions.v[0], NULL), DECLARE_LONGEST_MATCH); /* resolve declarations */ for (i = 0; i < g->declarations.n; i++) { e = g->declarations.v[i]->elem; if (e->kind == ELEM_UNRESOLVED) { if (e->e.unresolved.len == 0) p = g->productions.v[0]; else if (!(p = lookup_production(g, e->e.unresolved.string, e->e.unresolved.len))) d_fail("unresolved declaration '%s'", e->e.unresolved.string); FREE(e->e.unresolved.string); e->e.unresolved.string = 0; e->kind = ELEM_NTERM; e->e.nterm = p; } } /* build declaration groups (covering a production subtrees) */ for (i = 0; i < g->declarations.n; i++) { if (scanner_declaration(g->declarations.v[i])) { p = g->declarations.v[i]->elem->e.nterm; if (p == start) { for (j = 0; j < g->productions.n; j++) { g->productions.v[j]->declaration_group[g->declarations.v[i]->kind] = start; g->productions.v[j]->last_declaration[g->declarations.v[i]->kind] = g->declarations.v[i]; } } else set_declaration_group(p, p, g->declarations.v[i]); } } /* set terminal scan_kind */ for (i = 0; i < g->productions.n; i++) { p = g->productions.v[i]; for (j = 0; j < p->rules.n; j++) { r = p->rules.v[j]; for (k = 0; k < r->elems.n; k++) { e = r->elems.v[k]; if (e->kind == ELEM_TERM) { if (!p->declaration_group[DECLARE_LONGEST_MATCH] && !p->declaration_group[DECLARE_ALL_MATCHES]) e->e.term->scan_kind = D_SCAN_DEFAULT; else if (p->declaration_group[DECLARE_LONGEST_MATCH] && !p->declaration_group[DECLARE_ALL_MATCHES]) e->e.term->scan_kind = D_SCAN_LONGEST; else if (!p->declaration_group[DECLARE_LONGEST_MATCH] && p->declaration_group[DECLARE_ALL_MATCHES]) e->e.term->scan_kind = D_SCAN_ALL; else { if (p->last_declaration[DECLARE_LONGEST_MATCH]->index > p->last_declaration[DECLARE_ALL_MATCHES]->index) e->e.term->scan_kind = D_SCAN_LONGEST; else e->e.term->scan_kind = D_SCAN_ALL; } } } } } } static void merge_shift_actions(State *to, State *from) { int i, j; for (i = 0; i < from->shift_actions.n; i++) { for (j = 0; j < to->shift_actions.n; j++) if (from->shift_actions.v[i]->term == to->shift_actions.v[j]->term) goto Lnext; vec_add(&to->shift_actions, from->shift_actions.v[i]); Lnext:; } } static void compute_declaration_states(Grammar *g, Production *p, Declaration *d) { State *s, *base_s = NULL; int j, k, scanner = scanner_declaration(d); for (j = 0; j < g->states.n; j++) { s = g->states.v[j]; if (d->kind == DECLARE_TOKENIZE) { if (!base_s) base_s = s; else { s->same_shifts = base_s; merge_shift_actions(base_s, s); } } if (scanner) { for (k = 0; k < s->items.n; k++) if (s->items.v[k]->kind == ELEM_TERM) switch (s->items.v[k]->e.term->scan_kind) { case D_SCAN_LONGEST: if (s->scan_kind == D_SCAN_RESERVED || s->scan_kind == D_SCAN_LONGEST) s->scan_kind = D_SCAN_LONGEST; else s->scan_kind = D_SCAN_MIXED; break; case D_SCAN_ALL: if (s->scan_kind == D_SCAN_RESERVED || s->scan_kind == D_SCAN_ALL) s->scan_kind = D_SCAN_ALL; else s->scan_kind = D_SCAN_MIXED; break; default: break; } } } } static void map_declarations_to_states(Grammar *g) { int i; State *s; for (i = 0; i < g->states.n; i++) { s = g->states.v[i]; s->scan_kind = D_SCAN_RESERVED; } /* map groups to sets of states */ for (i = 0; i < g->declarations.n; i++) if (scanner_declaration(g->declarations.v[i])) compute_declaration_states(g, g->declarations.v[i]->elem->e.nterm, g->declarations.v[i]); for (i = 0; i < g->states.n; i++) { s = g->states.v[i]; if (s->scan_kind == D_SCAN_RESERVED) s->scan_kind = D_SCAN_DEFAULT; /* set the default */ } } int build_grammar(Grammar *g) { resolve_grammar(g); convert_regex_productions(g); propogate_declarations(g); merge_identical_terminals(g); make_elems_for_productions(g); check_default_actions(g); build_LR_tables(g); map_declarations_to_states(g); if (d_verbose_level) { printf("%d productions %d terminals %d states %d declarations\n", g->productions.n, g->terminals.n, g->states.n, g->declarations.n); } if (d_verbose_level > 1) { print_grammar(g); print_states(g); } build_scanners(g); build_eq(g); return 0; } /* Wlodek Bzyl, */ static void print_term_escaped(Term *t, int double_escaped) { char *s = 0; if (t->term_name) { printf("%s ", t->term_name); } else if (t->kind == TERM_STRING) { s = t->string ? escape_string_single_quote(t->string) : NULL; if (!t->string || !*t->string) printf(" "); else { printf("'%s' ", double_escaped?escape_string_single_quote(s):s); if (t->ignore_case) printf("/i "); if (t->term_priority) printf("%sterm %d ", double_escaped?"#":"$", t->term_priority); } } else if (t->kind == TERM_REGEX) { char *quote = double_escaped ? "\\\"" : "\""; s = t->string ? escape_string(t->string) : NULL; //char *s = t->string; // ? escape_string(t->string) : NULL; printf("%s%s%s ", quote, double_escaped?escape_string(s):s, quote); if (t->ignore_case) printf("/i "); if (t->term_priority) printf("%sterm %d ", double_escaped?"#":"$", t->term_priority); } else if (t->kind == TERM_CODE) { s = t->string ? escape_string(t->string) : NULL; printf("code(\"%s\") ", s); } else if (t->kind == TERM_TOKEN) { s = t->string ? escape_string(t->string) : NULL; printf("%s ", s); } else d_fail("unknown token kind"); if (s) FREE(s); } /* print_elem changed to call print_term_escaped */ static void print_element_escaped(Elem *ee, int double_escaped) { if (ee->kind == ELEM_TERM) print_term_escaped(ee->e.term, double_escaped); else if (ee->kind == ELEM_UNRESOLVED) printf("%s ", ee->e.unresolved.string); else printf("%s ", ee->e.nterm->name); } static void print_global_code(Grammar *g) { int i; int print_stdio_h = 1; printf("%%<"); for (i = 0; i < g->ncode; i++) { printf("%s", g->code[i].code); if (strstr(g->code[i].code, "") != NULL) print_stdio_h = 0; } if (print_stdio_h) printf("\n #include \n"); printf("%%>\n\n"); } static void print_production(Production *p) { uint j, k; Rule *r; char *opening[] = { "" , "\n\t [ printf(\"" , "\n\t { printf(\"" }; char *closing[] = { "\n" , "\\n\"); ]\n" , "\\n\"); }\n" }; char *middle[] = { "\n\t: ", " <- " , " <= " }; char *assoc[] = { "$" , "#" , "#" }; char *speculative_final_closing = "\\n\"); ]"; /* closing[1] without final newline */ char *next_or_rule = "\t| "; // char *regex_production = " ::= "; uint variant = 0; for (j = 0; j < p->rules.n; j++) { Lmore: r = p->rules.v[j]; if (!j) { // if (p->regex) { // printf("%s%s%s", opening[variant], p->name, regex_production); // } else { printf("%s%s%s", opening[variant], p->name, middle[variant]); // } } else { if (variant==0) printf("%s", next_or_rule); else printf("%s%s%s", opening[variant], p->name, middle[variant]); } for (k = 0; k < r->elems.n; k++) print_element_escaped(r->elems.v[k], variant); if (r->op_assoc) printf(" %s%s ", assoc[variant], assoc_str(r->op_assoc)+1); if (r->op_priority) printf("%d ", r->op_priority); if (r->rule_assoc) printf(" %s%s ", assoc[variant], assoc_str(r->rule_assoc)+1); if (r->rule_priority) printf("%d ", r->rule_priority); if ((d_rdebug_grammar_level == 1 && variant == 0) || (d_rdebug_grammar_level == 3 && variant == 0)) { variant=1; goto Lmore; } if ((d_rdebug_grammar_level == 2 && variant == 0) || (d_rdebug_grammar_level == 3 && variant == 1)) { if (variant==1) printf("%s", speculative_final_closing); variant=2; goto Lmore; } printf("%s", closing[variant]); variant = 0; } printf("\t;\n"); printf("\n"); } static void print_productions(Grammar *g, char *pathname) { uint i; if (!g->productions.n) { printf("/*\n There were no productions in the grammar %s\n*/\n", pathname); return; } for (i = 1; i < g->productions.n; i++) print_production(g->productions.v[i]); } static void print_declare(char *s, char *n) { while (*n && (isspace_(*n) || isdigit_(*n))) n++; printf(s, n); } static void print_declarations(Grammar *g) { int i; if (g->tokenizer) printf("${declare tokenize}\n"); for (i = 0; i < g->declarations.n; i++) { Declaration *dd = g->declarations.v[i]; Elem *ee = dd->elem; switch (dd->kind) { case DECLARE_LONGEST_MATCH: if (g->longest_match) printf("${declare longest_match}\n"); else print_declare("${declare longest_match %s}\n", ee->e.nterm->name); break; case DECLARE_ALL_MATCHES: if (!g->longest_match) printf("${declare all_matches}\n"); else print_declare("${declare all_matches %s}\n", ee->e.nterm->name); break; default: printf("\n/*\nDeclaration->kind: %d", dd->kind); printf("\nElem->kind: %d\n*/\n", ee->kind); } } if (g->set_op_priority_from_rule) printf("${declare set_op_priority_from_rule}\n"); if (g->states_for_all_nterms) printf("${declare all_subparsers}\n"); /* todo: DECLARE_STATE_FOR */ if (g->default_white_space) printf("${declare whitespace %s}\n", g->default_white_space); if (g->save_parse_tree) printf("${declare save_parse_tree}\n"); /* todo: DECLARE_NUM */ if (g->scanner.code) printf("${scanner %s}\n", g->scanner.code); { int token_exists = 0; for (i = 0; i < g->terminals.n; i++) { Term *t = g->terminals.v[i]; if (t->kind == TERM_TOKEN) { printf("%s %s", token_exists?"":"${token", t->string); token_exists = 1; } } if (token_exists) printf("}\n"); } printf("\n"); } void print_rdebug_grammar(Grammar *g, char *pathname) { char ver[30]; d_version(ver); printf("/*\n Generated by Make DParser Version %s\n", ver); printf(" Available at http://dparser.sf.net\n*/\n\n"); print_global_code(g); print_declarations(g); print_productions(g, pathname); } mcrl2-201210.1/3rd-party/dparser/lr.h000775 001751 001751 00000000425 12042421220 020173 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ #ifndef _lr_H_ #define _lr_H_ void build_LR_tables(Grammar *g); void sort_VecAction(VecAction *v); uint elem_symbol(Grammar *g, Elem *e); State *goto_State(State *s, Elem *e); void free_Action(Action *a); #endif mcrl2-201210.1/3rd-party/dparser/dparse_tree.h000775 001751 001751 00000003356 12042421220 022061 0ustar00jenkinsjenkins000000 000000 /* $URL: http://manta.univ.gda.pl/svn/wb/parsing/dparser/D/dparse_tree.h $ $Revision: 1.1 $ This interface provides a `print_parsetree' function that can be used to print a parse tree built by Dparser. The implementation of `print_parsetree' calls, on every node of the parse tree, a function `fn` that should print the node. Two such functions are provided: `print_node_default' which uses indentation to show the parse tree and `print_node_parenthesised' which uses parens. Three additional files provide an example: -- `driver_parsetree.c' contains a program illustrating the use of `print_parsetree', -- `4calc.g' contains a grammar for a simple calculator, -- `4calc.in' an expression to parse. The following commands can be used to compile and try out the example: make_dparser 4calc.g cc -o 4calc driver_parsetree.c 4calc.g.d_parser.c -I/usr/local/include -L/usr/local/lib -ldparse ./4calc 4calc.in */ #ifndef _parsetree_H_ #define _parsetree_H_ #include "dparse.h" /* `print_node_fn_t' type defines a class of callback functions that the `print_parsetree' function uses to print a node */ typedef void (print_node_fn_t)(int depth, char *token_name, char *token_value, void *client_data); /* if `fn' is NULL, then the function `print_node_default' is used */ void print_parsetree(D_ParserTables pt, D_ParseNode *pn, print_node_fn_t fn, void *client_data); /* `print_node_default' truncates `token_value' to 44 characters and replaces newlines with spaces */ void print_node_default(int depth, char *token_name, char *token_value, void *client_data); void print_node_parenthesised(int depth, char *token_name, char *token_value, void *client_data); #endif mcrl2-201210.1/3rd-party/dparser/gramgram.h000775 001751 001751 00000000511 12042421220 021347 0ustar00jenkinsjenkins000000 000000 /* Copyright 2002-2004 John Plevyak, All Rights Reserved */ struct Production; struct Rule; struct Elem; typedef struct ParseNode_User { struct Production *p; struct Rule *r; struct Elem *e; unsigned int kind; } ParseNode_User; #define D_ParseNode_User ParseNode_User #define D_ParseNode_Globals struct Grammar mcrl2-201210.1/3rd-party/dparser/dparse_tree.c000775 001751 001751 00000003521 12042421220 022046 0ustar00jenkinsjenkins000000 000000 /* $URL: http://manta.univ.gda.pl/svn/wb/parsing/dparser/D/dparse_tree.c $ $Revision: 1.2 $ */ #include #include #include "dparse_tree.h" char *dup_str(char *s, char *e); /* defined in util.h */ /* tunables */ #define MAX_LINE_LENGTH 44 /* must be at least 4 */ #define INDENT_SPACES 4 static void xprint_parsetree(D_ParserTables pt, D_ParseNode *pn, int depth, print_node_fn_t fn, void *client_data); static void xprint_parsetree(D_ParserTables pt, D_ParseNode *pn, int depth, print_node_fn_t fn, void *client_data) { int nch = d_get_number_of_children(pn), i; char *name = (char*)pt.symbols[pn->symbol].name; // int len = pn->end_skip - pn->start_loc.s; // char *value = malloc(len+2); // memcpy(value, pn->start_loc.s, len); // value[len] = 0; char *value = dup_str(pn->start_loc.s, pn->end); fn(depth, name, value, client_data); free(value); depth++; if (nch != 0) { for (i = 0; i < nch; i++) { D_ParseNode *xpn = d_get_child(pn,i); xprint_parsetree(pt, xpn, depth, fn, client_data); } } } void print_parsetree(D_ParserTables pt, D_ParseNode *pn, print_node_fn_t fn, void *client_data) { xprint_parsetree(pt, pn, 0, (NULL==fn)?print_node_default:fn, client_data); } void print_node_parenthesised(int depth, char *name, char *value, void *client_data) { printf("( %s )", name); } static char * change_newline2space(char *s) { char *ss = s; while (*ss++) if (*ss == '\n') *ss = ' '; if (strlen(s)>MAX_LINE_LENGTH) { *(s+MAX_LINE_LENGTH-3) = '.'; *(s+MAX_LINE_LENGTH-2) = '.'; *(s+MAX_LINE_LENGTH-1) = '.'; *(s+MAX_LINE_LENGTH) = '\0'; } return s; } void print_node_default(int depth, char *name, char *value, void *client_data) { printf("%*s", depth*INDENT_SPACES, ""); printf("%s %s.\n", name, change_newline2space(value)); } mcrl2-201210.1/3rd-party/dparser/read_binary.c000775 001751 001751 00000004762 12042421220 022040 0ustar00jenkinsjenkins000000 000000 #include "d.h" static void read_chk(void* ptr, size_t size, size_t nmemb, FILE* fp, unsigned char **str) { if (fp) { if (fread(ptr, size, nmemb, fp) != nmemb) d_fail("error reading binary tables\n"); } else { memcpy(ptr, *str, size * nmemb); (*str) += size * nmemb; } } BinaryTables * read_binary_tables_internal(FILE *fp, unsigned char *str, D_ReductionCode spec_code, D_ReductionCode final_code) { BinaryTablesHead tables; int i; BinaryTables * binary_tables = MALLOC(sizeof(BinaryTables)); char *tables_buf, *strings_buf; read_chk(&tables, sizeof(BinaryTablesHead), 1, fp, &str); tables_buf = MALLOC(tables.tables_size + tables.strings_size); read_chk(tables_buf, sizeof(char), tables.tables_size, fp, &str); strings_buf = tables_buf + tables.tables_size; read_chk(strings_buf, sizeof(char), tables.strings_size, fp, &str); for (i=0; iparser_tables_gram = (D_ParserTables*)(tables_buf + tables.d_parser_tables_loc); binary_tables->tables = tables_buf; return binary_tables; } BinaryTables * read_binary_tables(char *file_name, D_ReductionCode spec_code, D_ReductionCode final_code) { FILE *fp = fopen(file_name, "rb"); if (!fp) d_fail("error opening tables %s\n", file_name); return read_binary_tables_internal(fp, 0, spec_code, final_code); } BinaryTables * read_binary_tables_from_file(FILE *fp, D_ReductionCode spec_code, D_ReductionCode final_code) { return read_binary_tables_internal(fp, 0, spec_code, final_code); } BinaryTables * read_binary_tables_from_string(unsigned char *str, D_ReductionCode spec_code, D_ReductionCode final_code) { return read_binary_tables_internal(0, str, spec_code, final_code); } void free_BinaryTables(BinaryTables * binary_tables) { d_free(binary_tables->tables); d_free(binary_tables); } mcrl2-201210.1/libraries/lps/include/mcrl2/lps/action_parse.h000664 001751 001751 00000014547 12042421220 024761 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/action_parse.h /// \brief add your file description here. #ifndef MCRL2_LPS_ACTION_PARSE_H #define MCRL2_LPS_ACTION_PARSE_H #include "mcrl2/data/parse.h" #include "mcrl2/lps/multi_action.h" #include "mcrl2/lps/typecheck.h" namespace mcrl2 { namespace lps { struct action_actions: public data::data_specification_actions { action_actions(const core::parser_table& table_) : data::data_specification_actions(table_) {} atermpp::aterm_appl parse_Action(const core::parse_node& node) { return core::detail::gsMakeParamId(parse_Id(node.child(0)), parse_DataExprList(node.child(1))); } atermpp::aterm_list parse_ActionList(const core::parse_node& node) { return parse_list(node, "Action", boost::bind(&action_actions::parse_Action, this, _1)); } bool callback_ActDecl(const core::parse_node& node, action_label_vector& result) { if (symbol_name(node) == "ActDecl") { core::identifier_string_list ids = parse_IdList(node.child(0)); data::sort_expression_list sorts = parse_SortExprList(node.child(1)); for (core::identifier_string_list::iterator i = ids.begin(); i != ids.end(); ++i) { result.push_back(action_label(*i, sorts)); } return true; } return false; }; lps::action_label_list parse_ActDeclList(const core::parse_node& node) { action_label_vector result; traverse(node, boost::bind(&action_actions::callback_ActDecl, this, _1, boost::ref(result))); return lps::action_label_list(result.begin(), result.end()); } lps::action_label_list parse_ActSpec(const core::parse_node& node) { return parse_ActDeclList(node.child(1)); } lps::multi_action parse_MultAct(const core::parse_node& node) { if ((node.child_count() == 1) && (symbol_name(node.child(0)) == "tau")) { return lps::multi_action(); } else if ((node.child_count() == 1) && (symbol_name(node.child(0)) == "ActionList")) { return lps::multi_action(parse_ActionList(node.child(0))); } report_unexpected_node(node); return lps::action_list(); } }; inline multi_action parse_multi_action_new(const std::string& text) { core::parser p(parser_tables_mcrl2, core::detail::ambiguity_fn, core::detail::syntax_error_fn); unsigned int start_symbol_index = p.start_symbol_index("MultAct"); bool partial_parses = false; core::parse_node node = p.parse(text, start_symbol_index, partial_parses); multi_action result = action_actions(parser_tables_mcrl2).parse_MultAct(node); p.destroy_parse_node(node); return result; } inline void complete_multi_action(multi_action& x, const lps::action_label_list& action_decls, const data::data_specification& data_spec = data::detail::default_specification()) { lps::type_check(x, data_spec, action_decls); lps::translate_user_notation(x); lps::normalize_sorts(x, data_spec); } /// \brief Parses a multi_action from an input stream /// \param ma_stream An input stream containing a multi_action /// \param[in] action_decls A list of allowed action labels that is used for type checking. /// \param[in] data_spec The data specification that is used for type checking. /// \return The parsed multi_action /// \exception mcrl2::runtime_error when the input does not match the syntax of a multi action. inline multi_action parse_multi_action(std::stringstream& in, const lps::action_label_list& action_decls, const data::data_specification& data_spec = data::detail::default_specification()) { std::string text = utilities::read_text(in); multi_action result = parse_multi_action_new(text); complete_multi_action(result, action_decls, data_spec); return result; } /// \brief Parses a multi_action from a string /// \param text A string containing a multi_action /// \param[in] action_decls A list of allowed action labels that is used for type checking. /// \param[in] data_spec The data specification that is used for type checking. /// \return The parsed multi_action /// \exception mcrl2::runtime_error when the input does not match the syntax of a multi action. inline multi_action parse_multi_action(const std::string& text, const lps::action_label_list& action_decls, const data::data_specification& data_spec = data::detail::default_specification()) { std::stringstream ma_stream(text); return parse_multi_action(ma_stream, action_decls, data_spec); } /// \brief Parses an action declaration from a string /// \param text A string containing an action declaration /// \param[in] data_spec A data specification used for sort normalization /// \return A list of action labels /// \exception mcrl2::runtime_error when the input does not match the syntax of an action declaration. inline lps::action_label_list parse_action_declaration(const std::string& text, const data::data_specification& data_spec = data::detail::default_specification()) { core::parser p(parser_tables_mcrl2, core::detail::ambiguity_fn, core::detail::syntax_error_fn); unsigned int start_symbol_index = p.start_symbol_index("ActDecl"); bool partial_parses = false; core::parse_node node = p.parse(text, start_symbol_index, partial_parses); action_label_vector result; action_actions(parser_tables_mcrl2).callback_ActDecl(node, result); p.destroy_parse_node(node); lps::action_label_list v(result.begin(), result.end()); v = lps::normalize_sorts(v, data_spec); return v; } /// \brief Parses an action from a string /// \param text A string containing an action /// \param action_decls An action declaration /// \param[in] data_spec A data specification used for sort normalization /// \return An action /// \exception mcrl2::runtime_error when the input does not match the syntax of an action. inline action parse_action(const std::string& text, const lps::action_label_list& action_decls, const data::data_specification& data_spec = data::detail::default_specification()) { multi_action result = parse_multi_action(text, action_decls, data_spec); if (result.actions().size() != 1) { throw mcrl2::runtime_error("cannot parse '" + text + " as an action!"); } return result.actions().front(); } } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_ACTION_PARSE_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/state.h000664 001751 001751 00000002052 12042421220 023416 0ustar00jenkinsjenkins000000 000000 // Author(s): Jan Friso Groote // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/summand.h /// \brief The class summand. #ifndef MCRL2_LPS_STATE_H #define MCRL2_LPS_STATE_H #include "mcrl2/atermpp/vector.h" #include "mcrl2/data/data_expression.h" namespace mcrl2 { namespace lps { /// \brief A state type of fixed length in which data expressions can be stored. // The length is determined at runtime. class state: public atermpp::vector < mcrl2::data::data_expression > { public: state() { } state(data::data_expression_list arguments): atermpp::vector(arguments.begin(), arguments.end()) { } }; // template function overloads std::string pp(const lps::state& x); } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_STATE_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/simulation.h000664 001751 001751 00000007070 12042421220 024467 0ustar00jenkinsjenkins000000 000000 // Author(s): Ruud Koolen // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef MCRL2_LPS_SIMULATION_H #define MCRL2_LPS_SIMULATION_H #include #include "mcrl2/atermpp/deque.h" #include "mcrl2/data/rewriter.h" #include "mcrl2/lps/multi_action.h" #include "mcrl2/lps/next_state_generator.h" #include "mcrl2/lps/specification.h" #include "mcrl2/lps/state.h" namespace mcrl2 { namespace lps { /// \brief Simulation process. // A simulation is effectively a trace annotated with outgoing transition information // and an operation to extend the trace with an outgoing transition from the last state. class simulation { public: struct transition_t { state destination; multi_action action; }; struct state_t { state source_state; atermpp::vector transitions; size_t transition_number; // Undefined for the last state in the trace }; /// Constructor. simulation(const specification& specification, data::rewrite_strategy strategy = data::rewrite_strategy()); /// Returns the current annotated state vector. const atermpp::deque &trace() const { return m_tau_prioritization ? m_prioritized_trace : m_full_trace; } /// Remove states from the end of the simulation, making \a state_number the last state. void truncate(size_t state_number); /// Choose outgoing transition \a transition_number and add its state to the state vector. void select(size_t transition_number); /// If enabled, tau prioritization is applied to all outgoing transitions, and in-between states are hidden from the state vector. void enable_tau_prioritization(bool enable, std::string action = "ctau"); /// Save the trace to a file. void save(const std::string &filename); /// Load a trace from a file. void load(const std::string &filename); private: atermpp::vector transitions(state source_state); atermpp::vector prioritize(const atermpp::vector &transitions); bool is_prioritized(const multi_action &action); void prioritize_trace(); atermpp::deque match_trace(atermpp::deque trace, const atermpp::vector &transitions, size_t transition_number); bool match(const state &left, const state &right); private: specification m_specification; data::rewriter m_rewriter; next_state_generator m_generator; next_state_generator::substitution_t m_substitution; bool m_tau_prioritization; std::string m_prioritized_action; // The complete trace. atermpp::deque m_full_trace; // The trace with all prioritized in-between states removed. atermpp::deque m_prioritized_trace; std::deque m_prioritized_originals; }; } // namespace lps } // namespace mcrl2 namespace atermpp { template<> struct aterm_traits { static void protect(const mcrl2::lps::simulation::transition_t &transition) { aterm_traits::protect(transition.action); } static void unprotect(const mcrl2::lps::simulation::transition_t &transition) { aterm_traits::unprotect(transition.action); } static void mark(const mcrl2::lps::simulation::transition_t &transition) { aterm_traits::mark(transition.action); } }; } #endif mcrl2-201210.1/libraries/lps/include/mcrl2/lps/disjointness_checker.h000664 001751 001751 00000007646 12042421220 026514 0ustar00jenkinsjenkins000000 000000 // Author(s): Luc Engelen // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file include/disjointness_checker.h /// \brief Add your file description here. // Interface to class Disjointness_Checker // file: disjointness_checker.h #ifndef DISJOINTNESS_CHECKER_H #define DISJOINTNESS_CHECKER_H #include "mcrl2/lps/linear_process.h" /// \brief Class that can determine if two summands are syntactically disjoint. /// Two summands are syntactically disjoint if the following conditions hold: /// - The set of variables used by one summand is disjoint from the set of variables changed by the other summand and /// vice versa. /// - The set of variables changed by one summand is disjoint from the set of variables changed by the other summand. /// /// An instance of the class Disjointness_Checker is created using the constructor /// Disjointness_Checker::Disjointness_Checker. The parameter a_process_equations is used to pass the summands to be /// checked for disjointness. The function Disjointness_Checker::disjoint indicates whether the two summands with numbers /// a_summand_number_1 and a_summand_number_2 are syntactically disjoint. namespace mcrl2 { namespace lps { namespace detail { class Disjointness_Checker { private: /// \brief The number of summands of the LPS passed as argument of the constructor. size_t f_number_of_summands; /// \brief A two dimensional array, indicating which parameters a summand uses, for each of the summands. std::vector < atermpp::set < data::variable > > f_used_parameters_per_summand; /// \brief A two dimensional array, indicating which parameters a summand changes, for each of the summands. std::vector < atermpp::set < data::variable > > f_changed_parameters_per_summand; /// \brief Updates the array Disjointness_Checker::f_used_parameters_per_summand, given the expression a_expression. void process_data_expression(size_t a_summand_number, const data::data_expression a_expression); /// \brief Updates the array Disjointness_Checker::f_used_parameters_per_summand, given the multiaction a_multi_action. void process_multi_action(size_t a_summand_number, const multi_action a_multi_action); /// \brief Updates the arrays Disjointness_Checker::f_changed_parameters_per_summand and /// \brief Disjointness_Checker::f_used_parameters_per_summand, given the summand a_summand. void process_summand(size_t a_summand_number, const action_summand a_summand); public: /// \brief Constructor that initializes the sets Disjointness_Checker::f_used_parameters_per_summand and /// \brief Disjointness_Checker::f_changed_parameters_per_summand, and the indexed set /// \brief Disjointness_Checker::f_parameter_set. /// precondition: the argument passed as parameter a_process_equations is a specification of process equations in mCRL2 /// format /// precondition: the arguments passed as parameters a_summand_number_1 and a_summand_number_2 correspond to summands in /// the proces equations passed as parameter a_process_equations. They lie in the interval from and including 1 upto and /// including the highest summand number Disjointness_Checker(const linear_process& a_process_equation); /// \brief Destructor that frees the memory used by Disjointness_Checker::f_used_parameters_per_summand, /// \brief Disjointness_Checker::f_changed_parameters_per_summand and Disjointness_Checker::f_parameter_set. ~Disjointness_Checker(); /// \brief Indicates whether or not the summands with number a_summand_number_1 and a_summand_number_2 are disjoint. bool disjoint(const size_t a_summand_number_1, const size_t a_summand_number_2); }; } // namespace detail } // namespace lps } // namespace mcrl2 #endif mcrl2-201210.1/libraries/lps/include/mcrl2/lps/process_initializer.h000664 001751 001751 00000005113 12042421220 026360 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/process_initializer.h /// \brief The class process_initializer. #ifndef MCRL2_LPS_PROCESS_INITIALIZER_H #define MCRL2_LPS_PROCESS_INITIALIZER_H #include #include #include #include "mcrl2/atermpp/utility.h" #include "mcrl2/atermpp/convert.h" #include "mcrl2/core/detail/soundness_checks.h" #include "mcrl2/data/data_expression.h" #include "mcrl2/data/print.h" #include "mcrl2/data/detail/assignment_functional.h" #include "mcrl2/data/replace.h" #include "mcrl2/data/data_specification.h" namespace mcrl2 { namespace lps { /// \brief Initial state of a linear process. // LinearProcessInit(*, *) class process_initializer: public atermpp::aterm_appl { protected: /// \brief The assignments of the initializer data::assignment_list m_assignments; public: /// \brief Constructor. process_initializer() : atermpp::aterm_appl(mcrl2::core::detail::constructLinearProcessInit()) {} /// \brief Constructor. process_initializer(const data::assignment_list& assignments) : atermpp::aterm_appl(core::detail::gsMakeLinearProcessInit(assignments)), m_assignments(assignments) { } /// \brief Constructor. /// \param t A term process_initializer(atermpp::aterm_appl t) : atermpp::aterm_appl(t) { assert(core::detail::check_term_LinearProcessInit(m_term)); atermpp::aterm_appl::iterator i = t.begin(); m_assignments = *i; } /// \return The sequence of assignments. data::assignment_list assignments() const { return m_assignments; } /// \brief Returns the initial state of the LPS. /// \param process_parameters The parameters of the correponding linear process /// \return The initial state of the LPS. data::data_expression_list state(const data::variable_list& process_parameters) const { return data::replace_free_variables(atermpp::convert(process_parameters), data::assignment_sequence_substitution(m_assignments)); } }; // template function overloads std::string pp(const process_initializer& x); std::set find_free_variables(const lps::process_initializer& x); } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_PROCESS_INITIALIZER_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/translate_user_notation.h000664 001751 001751 00000002574 12042421220 027255 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/translate_user_notation.h /// \brief add your file description here. #ifndef MCRL2_LPS_TRANSLATE_USER_NOTATION_H #define MCRL2_LPS_TRANSLATE_USER_NOTATION_H #include "mcrl2/data/translate_user_notation.h" #include "mcrl2/lps/specification.h" #include "mcrl2/lps/builder.h" namespace mcrl2 { namespace lps { template void translate_user_notation(T& x, typename boost::disable_if::type>::type* = 0 ) { core::make_update_apply_builder(data::detail::translate_user_notation_function())(x); } template T translate_user_notation(const T& x, typename boost::enable_if::type>::type* = 0 ) { return core::make_update_apply_builder(data::detail::translate_user_notation_function())(x); } } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_TRANSLATE_USER_NOTATION_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/specification.h000664 001751 001751 00000023166 12042421220 025127 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/specification.h /// \brief The class specification. #ifndef MCRL2_LPS_SPECIFICATION_H #define MCRL2_LPS_SPECIFICATION_H #include #include #include #include #include #include #include #include #include #include "mcrl2/utilities/exception.h" #include "mcrl2/atermpp/aterm.h" #include "mcrl2/core/detail/aterm_io.h" #include "mcrl2/lps/linear_process.h" #include "mcrl2/lps/action.h" #include "mcrl2/lps/process_initializer.h" #include "mcrl2/data/data_specification.h" namespace mcrl2 { /// \brief The main namespace for the LPS library. namespace lps { template bool is_well_typed(const Object& o); class specification; atermpp::aterm_appl specification_to_aterm(const specification&); void complete_data_specification(lps::specification&); /// \brief Linear process specification. // sort ...; // // cons ...; // // map ...; // // eqn ...; // // proc P(b: Bool, n: Nat) = a(b).P() + sum c: Bool. b -\> e@1.P(b := c); // // init P(true, 0); // // ::= LinProcSpec(, , , // , ) class specification { protected: /// \brief The data specification of the specification data::data_specification m_data; /// \brief The action specification of the specification action_label_list m_action_labels; /// \brief The set of global variables atermpp::set m_global_variables; /// \brief The linear process of the specification linear_process m_process; /// \brief The initial state of the specification process_initializer m_initial_process; /// \brief Initializes the specification with an ATerm. /// \param t A term void construct_from_aterm(atermpp::aterm_appl t) { atermpp::aterm_appl::iterator i = t.begin(); m_data = atermpp::aterm_appl(*i++); m_action_labels = atermpp::aterm_appl(*i++)(0); data::variable_list global_variables = atermpp::aterm_appl(*i++)(0); m_global_variables = atermpp::convert >(global_variables); m_process = atermpp::aterm_appl(*i++); m_initial_process = atermpp::aterm_appl(*i); m_data.declare_data_specification_to_be_type_checked(); complete_data_specification(*this); } public: /// \brief Constructor. specification() { m_initial_process.protect(); } specification(specification const& other) { m_data = other.m_data; m_action_labels = other.m_action_labels; m_global_variables = other.m_global_variables; m_process = other.m_process; m_initial_process = other.m_initial_process; m_initial_process.protect(); } /// \brief Constructor. /// \param t A term specification(atermpp::aterm_appl t) { assert(core::detail::check_rule_LinProcSpec(t)); construct_from_aterm(t); m_initial_process.protect(); } /// \brief Constructor. /// \param data A data specification /// \param action_labels A sequence of action labels /// \param lps A linear process /// \param initial_process A process initializer specification(const data::data_specification& data, const action_label_list& action_labels, const atermpp::set& global_variables, const linear_process& lps, const process_initializer& initial_process) : m_data(data), m_action_labels(action_labels), m_global_variables(global_variables), m_process(lps), m_initial_process(initial_process) { m_initial_process.protect(); } /// \brief Reads the specification from file. /// \param filename A string /// If filename is nonempty, input is read from the file named filename. /// If filename is empty, input is read from standard input. void load(const std::string& filename) { atermpp::aterm t = core::detail::load_aterm(filename); if (!t || t.type() != AT_APPL || !core::detail::gsIsLinProcSpec(atermpp::aterm_appl(t))) { throw mcrl2::runtime_error(((filename.empty())?"stdin":("'" + filename + "'")) + " does not contain an LPS"); } //store the term locally construct_from_aterm(atermpp::aterm_appl(t)); // The well typedness check is only done in debug mode, since for large // LPSs it takes too much time assert(is_well_typed(*this)); } /// \brief Writes the specification to file. /// \param filename A string /// If filename is nonempty, output is written to the file named filename. /// If filename is empty, output is written to stdout. /// \param binary /// If binary is true the linear process is saved in compressed binary format. /// Otherwise an ascii representation is saved. In general the binary format is /// much more compact than the ascii representation. void save(const std::string& filename, bool binary = true) const { // The well typedness check is only done in debug mode, since for large // LPSs it takes too much time assert(is_well_typed(*this)); specification tmp(*this); core::detail::save_aterm(specification_to_aterm(tmp), filename, binary); } /// \brief Returns the linear process of the specification. /// \return The linear process of the specification. const linear_process& process() const { return m_process; } /// \brief Returns a reference to the linear process of the specification. /// \return The linear process of the specification. linear_process& process() { return m_process; } /// \brief Returns the data specification. /// \return The data specification. const data::data_specification& data() const { return m_data; } /// \brief Returns a reference to the data specification. /// \return The data specification. data::data_specification& data() { return m_data; } /// \brief Returns a sequence of action labels. /// This sequence contains all action labels occurring in the specification (but it can have more). /// \return A sequence of action labels. const action_label_list& action_labels() const { return m_action_labels; } /// \brief Returns a sequence of action labels. /// This sequence contains all action labels occurring in the specification (but it can have more). /// \return A sequence of action labels. action_label_list& action_labels() { return m_action_labels; } /// \brief Returns the declared free variables of the LPS. /// \return The declared free variables of the LPS. const atermpp::set& global_variables() const { return m_global_variables; } /// \brief Returns the declared free variables of the LPS. /// \return The declared free variables of the LPS. atermpp::set& global_variables() { return m_global_variables; } /// \brief Returns the initial process. /// \return The initial process. const process_initializer& initial_process() const { return m_initial_process; } /// \brief Returns a reference to the initial process. /// \return The initial process. process_initializer& initial_process() { return m_initial_process; } ~specification() { m_initial_process.unprotect(); } }; // template function overloads std::string pp(const specification& x); std::string pp_with_summand_numbers(const specification& x); std::set find_sort_expressions(const lps::specification& x); std::set find_variables(const lps::specification& x); std::set find_free_variables(const lps::specification& x); std::set find_function_symbols(const lps::specification& x); std::set find_identifiers(const lps::specification& x); /// \brief Adds all sorts that appear in the process of l to the data specification of l. /// \param l A linear process specification inline void complete_data_specification(lps::specification& spec) { std::set s = lps::find_sort_expressions(spec); spec.data().add_context_sorts(s); } /// \brief Conversion to ATermAppl. /// \return The specification converted to ATerm format. inline atermpp::aterm_appl specification_to_aterm(const specification& spec) { return core::detail::gsMakeLinProcSpec( data::detail::data_specification_to_aterm_data_spec(spec.data()), core::detail::gsMakeActSpec(spec.action_labels()), core::detail::gsMakeGlobVarSpec(atermpp::convert(spec.global_variables())), linear_process_to_aterm(spec.process()), spec.initial_process() ); } /// \brief Equality operator inline bool operator==(const specification& spec1, const specification& spec2) { return specification_to_aterm(spec1) == specification_to_aterm(spec2); } /// \brief Inequality operator inline bool operator!=(const specification& spec1, const specification& spec2) { return !(spec1 == spec2); } } // namespace lps } // namespace mcrl2 #ifndef MCRL2_LPS_DETAIL_LPS_WELL_TYPED_CHECKER_H #include "mcrl2/lps/detail/lps_well_typed_checker.h" #endif #endif // MCRL2_LPS_SPECIFICATION_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/typecheck.h000664 001751 001751 00000005252 12042421220 024262 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/typecheck.h /// \brief add your file description here. #ifndef MCRL2_LPS_TYPECHECK_H #define MCRL2_LPS_TYPECHECK_H #include "mcrl2/core/detail/struct_core.h" // gsMakeMultAct #include "mcrl2/core/detail/pp_deprecated.h" #include "mcrl2/core/typecheck.h" #include "mcrl2/lps/specification.h" namespace mcrl2 { namespace lps { /** \brief Type check a multi action * Throws an exception if something went wrong. * \param[in] mult_act A multi action that has not been type checked. * \post mult_action is type checked and sorts have been added when necessary. **/ inline void type_check( multi_action& mult_act, const data::data_specification& data_spec, const action_label_list& action_decls) { // TODO: replace all this nonsense code by a proper type check implementation ATermAppl t = core::type_check_mult_act( core::detail::gsMakeMultAct(mult_act.actions()), data::detail::data_specification_to_aterm_data_spec(data_spec), (ATermList)action_decls); if (!t) { throw mcrl2::runtime_error("could not type check multi action " + core::pp_deprecated(lps::detail::multi_action_to_aterm(mult_act))); } mult_act = multi_action(t); } /** \brief Type check a multi action * Throws an exception if something went wrong. * \param[in] mult_act A multi action that has not been type checked. * \post mult_action is type checked and sorts have been added when necessary. **/ inline void type_check( atermpp::vector& mult_actions, const data::data_specification& data_spec, const action_label_list& action_decls) { // TODO: replace all this nonsense code by a proper type check implementation // Bleh; do conversions... ATermList l=ATempty; for (atermpp::vector::const_iterator i=mult_actions.begin(); // Using a const_reverse_iterator does not compile on mac. i!=mult_actions.end(); ++i) { l=ATinsert(l,(ATerm)(ATermList)i->actions()); } l=core::type_check_mult_actions( ATreverse(l), data::detail::data_specification_to_aterm_data_spec(data_spec), (ATermList)action_decls); // And convert back... mult_actions.clear(); for (; !ATisEmpty(l) ; l=ATgetNext(l)) { mult_actions.push_back(multi_action((action_list)ATgetFirst(l))); } } } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_TYPECHECK_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/action_rename.h000664 001751 001751 00000075166 12042421220 025122 0ustar00jenkinsjenkins000000 000000 // Author(s): Jan Friso Groote, Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/action_rename.h /// \brief Action rename specifications. #ifndef MCRL2_LPS_ACTION_RENAME_H #define MCRL2_LPS_ACTION_RENAME_H #include "mcrl2/utilities/exception.h" #include "mcrl2/core/detail/struct_core.h" #include "mcrl2/core/parse.h" #include "mcrl2/core/typecheck.h" #include "mcrl2/utilities/logger.h" #include "mcrl2/lps/specification.h" #include "mcrl2/data/replace.h" #include "mcrl2/data/rewriter.h" #include "mcrl2/atermpp/vector.h" #include "mcrl2/data/data_expression.h" #include "mcrl2/data/data_specification.h" #include "mcrl2/data/set_identifier_generator.h" #include "mcrl2/lps/replace.h" #include "mcrl2/lps/find.h" // //Action rename rules // // ::= ActionRenameRules(*) // // //Action rename rule // // ::= ActionRenameRule(*, , // , ) // // //Right-hand side of an action rename rule // // ::= [- tc] // | [+ tc] // | Delta // | Tau // // //Action rename action_rename_specification // // ::= ActionRenameSpec(, , ) namespace mcrl2 { namespace lps { /// \brief Right hand side of an action rename rule class action_rename_rule_rhs: public atermpp::aterm_appl { public: /// \brief Default constructor. action_rename_rule_rhs() : atermpp::aterm_appl(core::detail::constructActionRenameRuleRHS()) {} /// \brief Returns true if the right hand side is equal to delta. /// \return True if the right hand side is equal to delta. bool is_delta() const { return core::detail::gsIsDelta(*this); } /// \brief Returns true if the right hand side is equal to tau. /// \return True if the right hand side is equal to tau. bool is_tau() const { return core::detail::gsIsTau(*this); } /// \brief Constructor. /// \param term A term action_rename_rule_rhs(const atermpp::aterm_appl& term) : atermpp::aterm_appl(term) { assert(core::detail::check_rule_ActionRenameRuleRHS(m_term)); } /// \brief Returns the action. /// \pre The right hand side must be an action /// \return The action. action act() const { if (is_tau() || is_delta()) { return action(); } atermpp::aterm_appl result = *this; return action(result); } }; // ::= ActionRenameRule(*, , // , ) /// \brief Action rename rule class action_rename_rule { protected: /// \brief The data variables of the rule data::variable_list m_variables; /// \brief The condition of the rule data::data_expression m_condition; /// \brief The left hand side of the rule atermpp::aterm_appl m_lhs; /// \brief right hand side of the rule action_rename_rule_rhs m_rhs; public: /// \brief Constructor. action_rename_rule() { } /// \brief Constructor. /// \param t A term action_rename_rule(atermpp::aterm_appl t) { assert(core::detail::check_rule_ActionRenameRule(t)); atermpp::aterm_appl::iterator i = t.begin(); m_variables = atermpp::aterm_list(*i++); m_condition = atermpp::aterm_appl(*i++); m_lhs = atermpp::aterm_appl(*i++); m_rhs = atermpp::aterm_appl(*i); } /// \brief Constructor. /// \param t A term action_rename_rule(const data::variable_list& variables, const data::data_expression& condition, const action& lhs, const action_rename_rule_rhs& rhs) : m_variables(variables), m_condition(condition), m_lhs(lhs), m_rhs(rhs) { } /// \brief Returns the variables of the rule. /// \return The variables of the rule. const data::variable_list& variables() const { return m_variables; } /// \brief Returns the variables of the rule. /// \return The variables of the rule. data::variable_list& variables() { return m_variables; } /// \brief Returns the condition of the rule. /// \return The condition of the rule. const data::data_expression& condition() const { return m_condition; } /// \brief Returns the condition of the rule. /// \return The condition of the rule. data::data_expression& condition() { return m_condition; } /// \brief Returns the left hand side of the rule. /// \return The left hand side of the rule. action lhs() const { return m_lhs; } /// \brief Returns the left hand side of the rule as an aterm_appl. /// Needed because it can contain a ParamId instead of an action. /// This is dictated by the type checker. /// \return The left hand side of the rule. atermpp::aterm_appl lhs_aterm() const { return m_lhs; } /// \brief Returns the right hand side of the rule. /// \return The right hand side of the rule. action_rename_rule_rhs rhs() const { return m_rhs; } // /// \brief Protects the aterms in this class void protect() const { m_variables.protect(); m_condition.protect(); m_lhs.protect(); m_rhs.protect(); } /// \brief Unprotects the aterms in this class void unprotect() const { m_variables.unprotect(); m_condition.unprotect(); m_lhs.unprotect(); m_rhs.unprotect(); } /// \brief Marks the aterms in this class void mark() const { m_variables.mark(); m_condition.mark(); m_lhs.mark(); m_rhs.mark(); } }; /// \brief Read-only singly linked list of action rename rules // typedef atermpp::term_list action_rename_rule_list; /// \brief Action rename specification class action_rename_specification { protected: /// \brief The data specification of the action rename specification data::data_specification m_data; /// \brief The action labels of the action rename specification action_label_list m_action_labels; /// \brief The action rename rules of the action rename specification atermpp::vector m_rules; public: /// \brief Constructor. action_rename_specification() { } /// \brief Constructor. /// \param t A term action_rename_specification(atermpp::aterm_appl t) { assert(core::detail::check_rule_ActionRenameSpec(t)); atermpp::aterm_appl::iterator i = t.begin(); m_data = atermpp::aterm_appl(*i++); m_action_labels = atermpp::aterm_appl(*i++)(0); atermpp::aterm_list rules_list = atermpp::aterm_appl(*i)(0); for (atermpp::aterm_list::const_iterator i=rules_list.begin(); i!=rules_list.end(); ++i) { m_rules.push_back(action_rename_rule(*i)); } } /// \brief Constructor. /// \param data A data specification /// \param action_labels A sequence of action labels /// \param rules A sequence of action rename rules action_rename_specification( const data::data_specification& data, const action_label_list action_labels, const atermpp::vector &rules) : m_data(data), m_action_labels(action_labels), m_rules(rules) { /* m_term = reinterpret_cast( core::detail::gsMakeActionRenameSpec( data::detail::data_specification_to_aterm_data_spec(data), core::detail::gsMakeActSpec(action_labels), core::detail::gsMakeActionRenameRules(rules) ) ); */ } /// \brief Returns the data action_rename_specification. /// \return The data action_rename_specification. const data::data_specification& data() const { return m_data; } /// \brief Returns the data specification. data::data_specification& data() { return m_data; } /// \brief Returns the sequence of action labels /// \return A sequence of action labels containing all action /// labels occurring in the action_rename_specification (but it can have more). const action_label_list& action_labels() const { return m_action_labels; } /// \brief Returns the sequence of action labels action_label_list& action_labels() { return m_action_labels; } /// \brief Returns the action rename rules. /// \return The action rename rules. const atermpp::vector& rules() const { return m_rules; } /// \brief Returns the action rename rules. atermpp::vector& rules() { return m_rules; } /// \brief Indicates whether the action_rename_specification is well typed. /// \return Always returns true. bool is_well_typed() const { return true; } /// \brief Protects the aterms in this class void protect() const { // m_data.protect(); m_action_labels.protect(); } /// \brief Unprotects the aterms in this class void unprotect() const { // m_data.unprotect(); m_action_labels.unprotect(); } /// \brief Marks the aterms in this class void mark() const { // m_data.mark(); m_action_labels.mark(); } }; inline atermpp::aterm_appl action_rename_rule_to_aterm(const action_rename_rule& rule) { return core::detail::gsMakeActionRenameRule(rule.variables(), rule.condition(), rule.lhs_aterm(), rule.rhs()); } inline atermpp::aterm_appl action_rename_specification_to_aterm(const action_rename_specification& spec) { atermpp::vector rules; for (atermpp::vector::const_iterator i = spec.rules().begin(); i != spec.rules().end(); ++i) { rules.push_back(action_rename_rule_to_aterm(*i)); } return core::detail::gsMakeActionRenameSpec( data::detail::data_specification_to_aterm_data_spec(spec.data()), core::detail::gsMakeActSpec(spec.action_labels()), core::detail::gsMakeActionRenameRules(atermpp::aterm_list(rules.begin(), rules.end())) ); } } } /// \cond INTERNAL_DOCS namespace atermpp { template<> struct aterm_traits { static void protect(const mcrl2::lps::action_rename_rule& t) { t.protect(); } static void unprotect(const mcrl2::lps::action_rename_rule& t) { t.unprotect(); } static void mark(const mcrl2::lps::action_rename_rule& t) { t.mark(); } }; template<> struct aterm_traits { static void protect(const mcrl2::lps::action_rename_specification& t) { t.protect(); } static void unprotect(const mcrl2::lps::action_rename_specification& t) { t.unprotect(); } static void mark(const mcrl2::lps::action_rename_specification& t) { t.mark(); } }; } // namespace atermpp /// \endcond namespace mcrl2 { namespace lps { /// \cond INTERNAL_DOCS namespace detail { /// \brief Type checks an action rename specification /// \param ar_spec A term /// \param spec A term /// \return A term in an undocumented format inline ATermAppl type_check_action_rename_specification(ATermAppl ar_spec, ATermAppl spec) { ATermAppl result = core::type_check_action_rename_spec(ar_spec, spec); if (result == NULL) { throw runtime_error("type check error"); } return result; } /// \brief Renames variables /// \param rcond A data expression /// \param rleft An action /// \param rright An action /// \param generator A generator for fresh identifiers template void rename_renamerule_variables(data::data_expression& rcond, lps::action& rleft, lps::action& rright, IdentifierGenerator& generator) { atermpp::map< data::variable, data::variable > renamings; std::set< data::variable > new_vars = data::find_variables(rleft.arguments()); for (std::set< data::variable >::const_iterator i = new_vars.begin(); i != new_vars.end(); ++i) { mcrl2::core::identifier_string new_name = generator(std::string(i->name())); if (new_name != i->name()) { renamings[*i] = data::variable(new_name, i->sort()); } } rcond = data::replace_free_variables(rcond, mcrl2::data::make_map_substitution(renamings)); rleft = lps::replace_free_variables(rleft, mcrl2::data::make_map_substitution(renamings)); rright = lps::replace_free_variables(rright, mcrl2::data::make_map_substitution(renamings)); } inline action translate_user_notation_and_normalise_sorts_action( const action &a, data::data_specification& data_spec) { return lps::normalize_sorts(lps::translate_user_notation(a),data_spec); } inline action_rename_rule_rhs translate_user_notation_and_normalise_sorts_action_rename_rule_rhs( const action_rename_rule_rhs& arr, data::data_specification& data_spec) { if (arr.is_delta() || arr.is_tau()) { return arr; } return translate_user_notation_and_normalise_sorts_action(arr.act(),data_spec); } inline action_rename_specification translate_user_notation_and_normalise_sorts_action_rename_spec(const action_rename_specification& ars) { data::data_specification data_spec=ars.data(); const action_label_list al=lps::normalize_sorts(ars.action_labels(),data_spec); atermpp::vector l(ars.rules()); for (atermpp::vector::iterator i=l.begin(); i!=l.end(); ++i) { *i = action_rename_rule(data::normalize_sorts(i->variables(),data_spec), data::normalize_sorts(data::translate_user_notation(i->condition()),data_spec), translate_user_notation_and_normalise_sorts_action(i->lhs(),data_spec), translate_user_notation_and_normalise_sorts_action_rename_rule_rhs(i->rhs(),data_spec)); } return action_rename_specification(data_spec,al,l); } } // namespace detail /// \endcond /// \brief Rename the actions in a linear specification using a given action_rename_spec /// \details The actions in a linear specification are renamed according to a given /// action rename specification. /// Note that the rules are applied in the order they appear in the specification. /// This yield quite elaborate conditions in the resulting lps, as a latter rule /// can only be applied if an earlier rule is not applicable. Note also that /// there is always a default summand, where the action is not renamed. Using /// sum elimination and rewriting a substantial reduction of the conditions that /// are generated can be obtained, often allowing many summands to be removed. /// \param action_rename_spec The action_rename_specification to be used. /// \param lps_old_spec The input linear specification. /// \return The lps_old_spec where all actions have been renamed according /// to action_rename_spec. inline lps::specification action_rename( const action_rename_specification& action_rename_spec, const lps::specification& lps_old_spec) { using namespace mcrl2::core; using namespace mcrl2::data; using namespace mcrl2::lps; using namespace std; const atermpp::vector rename_rules = action_rename_spec.rules(); action_summand_vector lps_old_action_summands = lps_old_spec.process().action_summands(); deadlock_summand_vector lps_deadlock_summands = lps_old_spec.process().deadlock_summands(); action_list lps_new_actions; data::set_identifier_generator generator; generator.add_identifiers(lps::find_identifiers(lps_old_spec)); //go through the rename rules of the rename file mCRL2log(log::debug) << "Rename rules found: " << rename_rules.size() << "\n"; for (atermpp::vector ::const_iterator i = rename_rules.begin(); i != rename_rules.end(); ++i) { action_summand_vector lps_new_action_summands; data_expression rule_condition = i->condition(); action rule_old_action = i->lhs(); action rule_new_action; action_rename_rule_rhs new_element = i->rhs(); rule_new_action = new_element.act(); const bool to_tau = new_element.is_tau(); const bool to_delta = new_element.is_delta(); // Check here that the arguments of the rule_old_action only consist // of uniquely occurring variables or closed terms. Furthermore, check that the variables // in rule_new_action and in rule_condition are a subset of those in // rule_old_action. This check ought to be done in the static checking // part of the renaming rules, but as yet it has nog been done. Ultimately // this check should be moved there. // first check that the arguments of rule_old_action are variables or closed // terms. for (data_expression_list::iterator rule_old_argument_i = rule_old_action.arguments().begin(); rule_old_argument_i != rule_old_action.arguments().end(); rule_old_argument_i++) { if (!is_variable(*rule_old_argument_i) && (!(data::find_variables(*rule_old_argument_i).empty()))) { throw mcrl2::runtime_error("The arguments of the lhs " + lps::pp(rule_old_action) + " are not variables or closed expressions"); } } // Check whether the variables in rhs are included in the lefthandside. std::set < variable > variables_in_old_rule = lps::find_free_variables(rule_old_action); std::set < variable > variables_in_new_rule = lps::find_free_variables(rule_new_action); if (!includes(variables_in_old_rule.begin(),variables_in_old_rule.end(), variables_in_new_rule.begin(),variables_in_new_rule.end())) { throw mcrl2::runtime_error("There are variables occurring in rhs " + lps::pp(rule_new_action) + " of a rename rule not occurring in lhs " + lps::pp(rule_old_action)); } // Check whether the variables in condition are included in the lefthandside. std::set < variable > variables_in_condition = data::find_free_variables(rule_condition); if (!includes(variables_in_old_rule.begin(),variables_in_old_rule.end(), variables_in_condition.begin(),variables_in_condition.end())) { throw mcrl2::runtime_error("There are variables occurring in the condition " + data::pp(rule_condition) + " of a rename rule not occurring in lhs " + lps::pp(rule_old_action)); } // check for double occurrences of variables in the lhs. Note that variables_in_old_rule // is empty at the end. for (data_expression_list::iterator i=rule_old_action.arguments().begin() ; i!=rule_old_action.arguments().end() ; i++) { if (is_variable(*i)) { if (variables_in_old_rule.find(*i)==variables_in_old_rule.end()) { throw mcrl2::runtime_error("Variable " + data::pp(*i) + " occurs more than once in lhs " + lps::pp(rule_old_action) + " of an action rename rule"); } else { variables_in_old_rule.erase(*i); } } } assert(variables_in_old_rule.empty()); //go through the summands of the old lps mCRL2log(log::debug) << "Action summands found: " << lps_old_action_summands.size() << "\n"; for (action_summand_vector::const_iterator losi = lps_old_action_summands.begin(); losi != lps_old_action_summands.end(); ++losi) { action_summand lps_old_action_summand = *losi; action_list lps_old_actions = lps_old_action_summand.multi_action().actions(); /* For each individual action in the multi-action, for which the rename rule applies, two new summands must be made, namely one where the rule does not match with the parameters of the action, and one where it actually does. This means that for a multiaction with k summands 2^k new summands can result. */ atermpp::vector < variable_list > lps_new_sum_vars(1,lps_old_action_summand.summation_variables()); atermpp::vector < data_expression > lps_new_condition(1,lps_old_action_summand.condition()); atermpp::vector < action_list > lps_new_actions(1,action_list()); std::vector < bool > lps_new_actions_is_delta(1,false); mCRL2log(log::debug) << "Actions in summand found: " << lps_old_actions.size() << "\n"; for (action_list::iterator loai = lps_old_actions.begin(); loai != lps_old_actions.end(); loai++) { action lps_old_action = *loai; if (equal_signatures(lps_old_action, rule_old_action)) { mCRL2log(log::debug) << "Renaming action " << lps::pp(rule_old_action) << "\n"; //rename all previously used variables data_expression renamed_rule_condition=rule_condition; action renamed_rule_old_action=rule_old_action; action renamed_rule_new_action=rule_new_action; detail::rename_renamerule_variables(renamed_rule_condition, renamed_rule_old_action, renamed_rule_new_action, generator); //go through the arguments of the action data_expression_list::iterator lps_old_argument_i = lps_old_action.arguments().begin(); data_expression new_equalities_condition=sort_bool::true_(); for (data_expression_list::iterator rule_old_argument_i = renamed_rule_old_action.arguments().begin(); rule_old_argument_i != renamed_rule_old_action.arguments().end(); rule_old_argument_i++) { if (is_variable(*rule_old_argument_i)) { new_equalities_condition=lazy::and_(new_equalities_condition, data::equal_to(*rule_old_argument_i, *lps_old_argument_i)); } else { assert((data::find_variables(*rule_old_argument_i).empty())); // the argument must be closed, // which is checked above. renamed_rule_condition= lazy::and_(renamed_rule_condition, data::equal_to(*rule_old_argument_i, *lps_old_argument_i)); } lps_old_argument_i++; } /* insert the new equality condition in all the newly generated summands */ for (atermpp::vector < data_expression > :: iterator i=lps_new_condition.begin() ; i!=lps_new_condition.end() ; i++) { *i=lazy::and_(*i,new_equalities_condition); } /* insert the new sum variables in all the newly generated summands */ std::set new_vars = find_variables(renamed_rule_old_action); for (std::set::iterator sdvi = new_vars.begin(); sdvi != new_vars.end(); sdvi++) { for (atermpp::vector < variable_list > :: iterator i=lps_new_sum_vars.begin() ; i!=lps_new_sum_vars.end() ; i++) { *i = push_front(*i, *sdvi); } } if (renamed_rule_condition==sort_bool::true_()) { if (to_delta) { std::vector < bool >::iterator i_is_delta=lps_new_actions_is_delta.begin(); for (atermpp::vector < action_list > :: iterator i=lps_new_actions.begin() ; i!=lps_new_actions.end() ; ++i,++i_is_delta) { *i=action_list(); // the action becomes delta *i_is_delta=true; } } else if (!to_tau) { std::vector < bool >::iterator i_is_delta=lps_new_actions_is_delta.begin(); for (atermpp::vector < action_list > :: iterator i=lps_new_actions.begin() ; i!=lps_new_actions.end() ; ++i,++i_is_delta) { if (!*i_is_delta) // the action is not delta { *i=push_front(*i,renamed_rule_new_action); } } } } else if (renamed_rule_condition==sort_bool::false_()) { std::vector < bool >::iterator i_is_delta=lps_new_actions_is_delta.begin(); for (atermpp::vector < action_list > :: iterator i=lps_new_actions.begin() ; i!=lps_new_actions.end() ; ++i,++i_is_delta) { if (!*i_is_delta) // The action does not equal delta. { *i=push_front(*i,lps_old_action); } } } else { /* Duplicate summands, one where the renaming is applied, and one where it is not applied. */ atermpp::vector < action_list > lps_new_actions_temp(lps_new_actions); if (!to_tau) // if the new element is tau, we do not insert it in the multi-action. { std::vector < bool >::iterator i_is_delta=lps_new_actions_is_delta.begin(); for (atermpp::vector < action_list > :: iterator i=lps_new_actions.begin() ; i!=lps_new_actions.end() ; ++i,++i_is_delta) { if (to_delta) { *i=action_list(); *i_is_delta=true; } else { *i=push_front(*i,renamed_rule_new_action); *i_is_delta=false; } } } for (atermpp::vector < action_list > :: iterator i=lps_new_actions_temp.begin() ; i!=lps_new_actions_temp.end() ; ++i) { lps_new_actions_is_delta.push_back(false); // An non renamed action is not delta; *i=push_front(*i,lps_old_action); } lps_new_actions.insert(lps_new_actions.end(), lps_new_actions_temp.begin(), lps_new_actions_temp.end()); assert(lps_new_actions_is_delta.size()==lps_new_actions.size()); /* lps_new_condition_temp will contain the conditions in conjunction with the negated new_condition. It will be concatenated to lps_new_condition, in which the terms will be conjoined with the non-negated new_condition */ atermpp::vector < data_expression > lps_new_condition_temp(lps_new_condition); for (atermpp::vector < data_expression > :: iterator i=lps_new_condition.begin() ; i!=lps_new_condition.end() ; i++) { *i=lazy::and_(*i,renamed_rule_condition); } for (atermpp::vector < data_expression > :: iterator i=lps_new_condition_temp.begin() ; i!=lps_new_condition_temp.end() ; i++) { *i=lazy::and_(*i,sort_bool::not_(renamed_rule_condition)); } lps_new_condition.insert(lps_new_condition.end(), lps_new_condition_temp.begin(), lps_new_condition_temp.end()); atermpp::vector < variable_list > lps_new_sum_vars_temp(lps_new_sum_vars); lps_new_sum_vars.insert(lps_new_sum_vars.end(), lps_new_sum_vars_temp.begin(), lps_new_sum_vars_temp.end()); } }//end if(equal_signatures(...)) else { for (atermpp::vector < action_list > :: iterator i=lps_new_actions.begin() ; i!=lps_new_actions.end() ; ++i) { *i = push_front(*i, lps_old_action); } } mCRL2log(log::debug) << "Action done\n"; } //end of action list iterator /* Add the summands to lps_new_action_summands or to the deadlock summands*/ atermpp::vector < action_list > :: iterator i_act=lps_new_actions.begin(); std::vector < bool > :: iterator i_act_is_delta=lps_new_actions_is_delta.begin(); atermpp::vector < variable_list > :: iterator i_sumvars=lps_new_sum_vars.begin(); for (atermpp::vector < data_expression > :: iterator i_cond=lps_new_condition.begin() ; i_cond!=lps_new_condition.end() ; ++i_cond, ++i_act_is_delta) { //create a summand for the new lps if (*i_act_is_delta) { // Create a deadlock summand. const deadlock_summand d(*i_sumvars, *i_cond, deadlock(lps_old_action_summand.multi_action().time())); lps_deadlock_summands.push_back(d); } else { // create an action summand. action_summand lps_new_summand(*i_sumvars, *i_cond, multi_action(reverse(*i_act), lps_old_action_summand.multi_action().time()), lps_old_action_summand.assignments()); lps_new_action_summands.push_back(lps_new_summand); } i_act++; i_sumvars++; } } // end of summand list iterator lps_old_action_summands = lps_new_action_summands; } //end of rename rule iterator mCRL2log(log::debug) << "Simplifying the result...\n"; linear_process new_process(lps_old_spec.process().process_parameters(), lps_deadlock_summands, lps_old_action_summands); // add action_rename_spec.action_labels to action_rename_spec.action_labels without adding duplates. action_label_list all=action_rename_spec.action_labels(); for (action_label_list::const_iterator i=lps_old_spec.action_labels().begin(); i!=lps_old_spec.action_labels().end(); ++i) { if (find(action_rename_spec.action_labels().begin(), action_rename_spec.action_labels().end(),*i)==action_rename_spec.action_labels().end()) { // Not found; all=push_front(all,*i); } } specification lps_new_spec = specification( action_rename_spec.data(), // This contains the data of the lps and the rename file. all, lps_old_spec.global_variables(), new_process, lps_old_spec.initial_process()); mCRL2log(log::debug) << "New lps complete\n"; return lps_new_spec; } //end of rename(...) } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_ACTION_RENAME_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/normalize_sorts.h000664 001751 001751 00000002643 12042421220 025536 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/normalize_sorts.h /// \brief add your file description here. #ifndef MCRL2_LPS_NORMALIZE_SORTS_H #define MCRL2_LPS_NORMALIZE_SORTS_H #include "mcrl2/data/normalize_sorts.h" #include "mcrl2/lps/specification.h" #include "mcrl2/lps/builder.h" namespace mcrl2 { namespace lps { template void normalize_sorts(T& x, const data::data_specification& data_spec, typename boost::disable_if::type>::type* = 0 ) { core::make_update_apply_builder(data::detail::normalize_sorts_function(data_spec))(x); } template T normalize_sorts(const T& x, const data::data_specification& data_spec, typename boost::enable_if::type>::type* = 0 ) { return core::make_update_apply_builder(data::detail::normalize_sorts_function(data_spec))(x); } } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_NORMALIZE_SORTS_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/action_label.h000664 001751 001751 00000005472 12042421220 024723 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/action_label.h /// \brief The class action_label. #ifndef MCRL2_LPS_ACTION_LABEL_H #define MCRL2_LPS_ACTION_LABEL_H #include #include #include "mcrl2/atermpp/aterm_appl.h" #include "mcrl2/atermpp/aterm_list.h" #include "mcrl2/atermpp/vector.h" #include "mcrl2/core/identifier_string.h" #include "mcrl2/core/detail/soundness_checks.h" #include "mcrl2/data/data_specification.h" namespace mcrl2 { namespace lps { //--- start generated class action_label ---// /// \brief An action label class action_label: public atermpp::aterm_appl { public: /// \brief Default constructor. action_label() : atermpp::aterm_appl(core::detail::constructActId()) {} /// \brief Constructor. /// \param term A term action_label(const atermpp::aterm_appl& term) : atermpp::aterm_appl(term) { assert(core::detail::check_term_ActId(m_term)); } /// \brief Constructor. action_label(const core::identifier_string& name, const data::sort_expression_list& sorts) : atermpp::aterm_appl(core::detail::gsMakeActId(name, sorts)) {} /// \brief Constructor. action_label(const std::string& name, const data::sort_expression_list& sorts) : atermpp::aterm_appl(core::detail::gsMakeActId(core::identifier_string(name), sorts)) {} core::identifier_string name() const { return atermpp::arg1(*this); } data::sort_expression_list sorts() const { return atermpp::list_arg2(*this); } }; /// \brief list of action_labels typedef atermpp::term_list action_label_list; /// \brief vector of action_labels typedef atermpp::vector action_label_vector; /// \brief Test for a action_label expression /// \param t A term /// \return True if it is a action_label expression inline bool is_action_label(const atermpp::aterm_appl& t) { return core::detail::gsIsActId(t); } //--- end generated class action_label ---// // template function overloads std::string pp(const action_label& x); std::string pp(const action_label_list& x); std::string pp(const action_label_vector& x); action_label_list normalize_sorts(const action_label_list& x, const data::data_specification& dataspec); std::set find_sort_expressions(const lps::action_label_list& x); // TODO: These should be removed when the ATerm code has been replaced. std::string pp(const atermpp::aterm& x); std::string pp(const atermpp::aterm_appl& x); } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_ACTION_LABEL_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/linear_process.h000664 001751 001751 00000020052 12042421220 025306 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/linear_process.h /// \brief The class linear_process. #ifndef MCRL2_LPS_LINEAR_PROCESS_H #define MCRL2_LPS_LINEAR_PROCESS_H #include #include #include #include #include "mcrl2/atermpp/aterm.h" #include "mcrl2/atermpp/aterm_list.h" #include "mcrl2/data/data_specification.h" #include "mcrl2/lps/summand.h" #include "mcrl2/lps/process_initializer.h" namespace mcrl2 { namespace lps { class linear_process; // prototype declaration /////////////////////////////////////////////////////////////////////////////// // linear_process /// \brief linear process. // ::= LinearProcess(*, *) class linear_process { friend atermpp::aterm_appl linear_process_to_aterm(const linear_process& p); protected: /// \brief The process parameters of the process data::variable_list m_process_parameters; /// \brief The deadlock summands of the process deadlock_summand_vector m_deadlock_summands; /// \brief The action summands of the process action_summand_vector m_action_summands; /// \brief Set the summands of the linear process /// \deprecated void set_summands(const deprecated::summand_list& summands) { m_deadlock_summands.clear(); m_action_summands .clear(); for (deprecated::summand_list::iterator j = summands.begin(); j != summands.end(); ++j) { if (j->is_delta()) { m_deadlock_summands.push_back(deadlock_summand(j->summation_variables(), j->condition(), j->deadlock())); } else { m_action_summands.push_back(action_summand(j->summation_variables(), j->condition(), j->multi_action(), j->assignments())); } } } /// \brief Returns the sequence of LPS summands. /// \return The sequence of LPS summands. /// \deprecated deprecated::summand_list summands() const { deprecated::summand_list result; for (deadlock_summand_vector::const_reverse_iterator i = m_deadlock_summands.rbegin(); i != m_deadlock_summands.rend(); ++i) { deprecated::summand s = atermpp::aterm_appl(deadlock_summand_to_aterm(*i)); result = atermpp::push_front(result, s); } for (action_summand_vector::const_reverse_iterator i = m_action_summands.rbegin(); i != m_action_summands.rend(); ++i) { deprecated::summand s = atermpp::aterm_appl(action_summand_to_aterm(*i)); result = atermpp::push_front(result, s); } return result; } public: /// \brief Constructor. linear_process() { m_process_parameters.protect(); } /// \brief Copy constructor. linear_process(const linear_process &other) : m_process_parameters(other.m_process_parameters), m_deadlock_summands(other.m_deadlock_summands), m_action_summands(other.m_action_summands) { m_process_parameters.protect(); } /// \brief Constructor. linear_process(const data::variable_list& process_parameters, const deadlock_summand_vector& deadlock_summands, const action_summand_vector& action_summands ) : m_process_parameters(process_parameters), m_deadlock_summands(deadlock_summands), m_action_summands(action_summands) { m_process_parameters.protect(); } /// \brief Constructor. /// \param lps A term linear_process(atermpp::aterm_appl lps) { assert(core::detail::check_term_LinearProcess(lps)); // unpack LPS(.,.,.) term atermpp::aterm_appl::iterator i = lps.begin(); m_process_parameters = *i++; m_process_parameters.protect(); set_summands(*i); } /// \brief Destructor ~linear_process() { m_process_parameters.unprotect(); } /// \brief Returns the number of LPS summands. /// \return The number of LPS summands. size_t summand_count() const { return m_deadlock_summands.size() + m_action_summands.size(); } /// \brief Returns the sequence of action summands. /// \return The sequence of action summands. const action_summand_vector& action_summands() const { return m_action_summands; } /// \brief Returns the sequence of action summands. /// \return The sequence of action summands. action_summand_vector& action_summands() { return m_action_summands; } /// \brief Returns the sequence of deadlock summands. /// \return The sequence of deadlock summands. const deadlock_summand_vector& deadlock_summands() const { return m_deadlock_summands; } /// \brief Returns the sequence of deadlock summands. /// \return The sequence of deadlock summands. deadlock_summand_vector& deadlock_summands() { return m_deadlock_summands; } /// \brief Returns the sequence of process parameters. /// \return The sequence of process parameters. const data::variable_list& process_parameters() const { return m_process_parameters; } /// \brief Returns the sequence of process parameters. /// \return The sequence of process parameters. data::variable_list& process_parameters() { return m_process_parameters; } /// \brief Returns true if time is available in at least one of the summands. /// \return True if time is available in at least one of the summands. bool has_time() const { for (action_summand_vector::const_iterator i = m_action_summands.begin(); i != m_action_summands.end(); ++i) { if (i->has_time()) { return true; } } for (deadlock_summand_vector::const_iterator i = m_deadlock_summands.begin(); i != m_deadlock_summands.end(); ++i) { if (i->deadlock().has_time()) { return true; } } return false; } }; /// \brief Conversion to ATermAppl. /// \return The action summand converted to ATerm format. inline atermpp::aterm_appl linear_process_to_aterm(const linear_process& p) { return core::detail::gsMakeLinearProcess( p.process_parameters(), p.summands() ); } namespace deprecated { /// \brief Set the summands of the linear process /// \deprecated inline void set_linear_process_summands(linear_process& p, const summand_list& summands) { p.deadlock_summands().clear(); p.action_summands().clear(); for (summand_list::iterator j = summands.begin(); j != summands.end(); ++j) { if (j->is_delta()) { p.deadlock_summands().push_back(deadlock_summand(j->summation_variables(), j->condition(), j->deadlock())); } else { p.action_summands().push_back(action_summand(j->summation_variables(), j->condition(), j->multi_action(), j->assignments())); } } } /// \brief Returns the sequence of LPS summands. /// \return The sequence of LPS summands. /// \deprecated inline summand_list linear_process_summands(const linear_process& p) { summand_list result; for (deadlock_summand_vector::const_reverse_iterator i = p.deadlock_summands().rbegin(); i != p.deadlock_summands().rend(); ++i) { summand s = atermpp::aterm_appl(deadlock_summand_to_aterm(*i)); result = atermpp::push_front(result, s); } for (action_summand_vector::const_reverse_iterator i = p.action_summands().rbegin(); i != p.action_summands().rend(); ++i) { summand s = atermpp::aterm_appl(action_summand_to_aterm(*i)); result = atermpp::push_front(result, s); } return result; } } // namespace deprecated // template function overloads std::string pp(const linear_process& x); std::set find_variables(const lps::linear_process& x); std::set find_free_variables(const lps::linear_process& x); } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_LINEAR_PROCESS_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/linearisation_method.h000664 001751 001751 00000004711 12042421220 026503 0ustar00jenkinsjenkins000000 000000 // Author(s): Unknown // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/linearisation_method.h #ifndef MCRL2_LPS_LINEARISATION_METHOD_H #define MCRL2_LPS_LINEARISATION_METHOD_H #include #include #include "mcrl2/utilities/exception.h" namespace mcrl2 { namespace lps { /// \brief The available linearisation methods typedef enum { lmStack, lmRegular, lmRegular2 } t_lin_method; /// \brief String representation of a linearisation method /// \param[in] lin_method A linerisation method /// \return String representation of \a lin_method inline std::string print_lin_method(const t_lin_method lin_method) { switch(lin_method) { case lmStack: return "stack"; case lmRegular: return "regular"; case lmRegular2: return "regular2"; default: throw mcrl2::runtime_error("unknown linearisation method"); } } inline std::string description(const t_lin_method lin_method) { switch(lin_method) { case lmStack: return "for using stack data types (useful when 'regular' and 'regular2' do not work)"; case lmRegular: return "for generating an LPS in regular form (specification should be regular)"; case lmRegular2: return "for a variant of 'regular' that uses more data variables (useful when 'regular' does not work)"; default: throw mcrl2::runtime_error("unknown linearisation method"); } } /// \brief Parse a linearisation method /// \param[in] s A string /// \return The linearisation method represented by \a s inline t_lin_method parse_lin_method(const std::string& s) { if(s == "stack") { return lmStack; } else if (s == "regular") { return lmRegular; } else if (s == "regular2") { return lmRegular2; } else { throw mcrl2::runtime_error("unknown linearisation strategy " + s); } } // \overload inline std::istream& operator>>(std::istream& is, t_lin_method& l) { try { std::string s; is >> s; l = parse_lin_method(s); } catch (mcrl2::runtime_error&) { is.setstate(std::ios_base::failbit); } return is; } // \overload inline std::ostream& operator<<(std::ostream& os, const t_lin_method l) { os << print_lin_method(l); return os; } } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_LINEARISATION_METHOD_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/nextstate/nextstate_options.h000664 001751 001751 00000004307 12042421220 030114 0ustar00jenkinsjenkins000000 000000 // Author(s): Muck van Weerdenburg // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/nextstate/nextstate_options.h #ifndef MCRL2_LPS_NEXTSTATE_NEXTSTATE_OPTIONS_H #define MCRL2_LPS_NEXTSTATE_NEXTSTATE_OPTIONS_H #include #include #include "mcrl2/utilities/exception.h" namespace mcrl2 { namespace lps { /** \brief Internal NextState state storage method **/ typedef enum { GS_STATE_VECTOR /** \brief Store state as vector (ATermAppl) **/ , GS_STATE_TREE /** \brief Store states in a binary tree **/ } NextStateFormat; inline NextStateFormat parse_nextstate_format(const std::string& s) { if(s == "vector") { return GS_STATE_VECTOR; } else if (s == "tree") { return GS_STATE_TREE; } else { throw mcrl2::runtime_error("unknown nextstate format " + s); } } inline std::string print_nextstate_format(const NextStateFormat f) { switch(f) { case GS_STATE_VECTOR: return "vector"; case GS_STATE_TREE: return "tree"; default: throw mcrl2::runtime_error("unknown nextstate format"); } } inline std::istream& operator>>(std::istream& is, NextStateFormat& f) { try { std::string s; is >> s; f = parse_nextstate_format(s); } catch (mcrl2::runtime_error&) { is.setstate(std::ios_base::failbit); } return is; } inline std::ostream& operator<<(std::ostream& os, const NextStateFormat f) { os << print_nextstate_format(f); return os; } inline std::string description(const NextStateFormat f) { switch(f) { case GS_STATE_VECTOR: return "a vector (slightly faster, often far less memory efficient)"; case GS_STATE_TREE: return "a tree (memory efficient)"; default: throw mcrl2::runtime_error("unknown nextstate format"); } } /** \brief Strategies for exploring the next states. **/ typedef enum { nsStandard } NextStateStrategy; } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_NEXTSTATE_NEXTSTATE_OPTIONS_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/parse.h000664 001751 001751 00000020056 12042421220 023414 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/parse.h /// \brief add your file description here. #ifndef MCRL2_LPS_PARSE_H #define MCRL2_LPS_PARSE_H #include #include "mcrl2/atermpp/convert.h" #include "mcrl2/utilities/exception.h" #include "mcrl2/data/parse.h" #include "mcrl2/lps/action_parse.h" #include "mcrl2/lps/detail/linear_process_conversion_traverser.h" #include "mcrl2/lps/action_rename.h" #include "mcrl2/lps/specification.h" #include "mcrl2/lps/typecheck.h" #include "mcrl2/process/is_linear.h" #include "mcrl2/process/parse.h" namespace mcrl2 { namespace lps { struct action_rename_actions: public lps::action_actions { action_rename_actions(const core::parser_table& table_) : lps::action_actions(table_) {} lps::action_rename_rule_rhs parse_ActionRenameRuleRHS(const core::parse_node& node) { if ((node.child_count() == 1) && (symbol_name(node.child(0)) == "Action")) { return action_rename_rule_rhs(parse_Action(node.child(0))); } else if ((node.child_count() == 1) && (symbol_name(node.child(0)) == "tau")) { return action_rename_rule_rhs(core::detail::gsMakeTau()); } else if ((node.child_count() == 1) && (symbol_name(node.child(0)) == "delta")) { return action_rename_rule_rhs(core::detail::gsMakeDelta()); } report_unexpected_node(node); return lps::action_rename_rule_rhs(); } lps::action_rename_rule parse_ActionRenameRule(const core::parse_node& node) { data::data_expression condition = data::sort_bool::true_(); if (node.child(0).child(0)) { condition = parse_DataExpr(node.child(0).child(0).child(0)); } return action_rename_rule(core::detail::gsMakeActionRenameRule(data::variable_list(), condition, parse_Action(node.child(1)), parse_ActionRenameRuleRHS(node.child(3)))); } atermpp::vector parse_ActionRenameRuleList(const core::parse_node& node) { return parse_vector(node, "ActionRenameRule", boost::bind(&action_rename_actions::parse_ActionRenameRule, this, _1)); } atermpp::vector parse_ActionRenameRuleSpec(const core::parse_node& node) { data::variable_list variables = parse_VarSpec(node.child(0)); atermpp::vector rules = parse_ActionRenameRuleList(node.child(2)); for (atermpp::vector::iterator i = rules.begin(); i != rules.end(); ++i) { i->variables() = variables; } return rules; } bool callback_ActionRenameSpec(const core::parse_node& node, lps::action_rename_specification& result) { if (symbol_name(node) == "SortSpec") { return callback_DataSpecElement(node, result.data()); } else if (symbol_name(node) == "ConsSpec") { return callback_DataSpecElement(node, result.data()); } else if (symbol_name(node) == "MapSpec") { return callback_DataSpecElement(node, result.data()); } else if (symbol_name(node) == "EqnSpec") { return callback_DataSpecElement(node, result.data()); } else if (symbol_name(node) == "ActSpec") { result.action_labels() = parse_ActSpec(node); return true; } else if (symbol_name(node) == "ActionRenameRuleSpec") { atermpp::vector rules = parse_ActionRenameRuleSpec(node); result.rules().insert(result.rules().end(), rules.begin(), rules.end()); return true; } return false; } lps::action_rename_specification parse_ActionRenameSpec(const core::parse_node& node) { lps::action_rename_specification result; traverse(node, boost::bind(&action_rename_actions::callback_ActionRenameSpec, this, _1, boost::ref(result))); return result; } }; inline action_rename_specification parse_action_rename_specification_new(const std::string& text) { core::parser p(parser_tables_mcrl2, core::detail::ambiguity_fn, core::detail::syntax_error_fn); unsigned int start_symbol_index = p.start_symbol_index("ActionRenameSpec"); bool partial_parses = false; core::parse_node node = p.parse(text, start_symbol_index, partial_parses); action_rename_specification result = action_rename_actions(parser_tables_mcrl2).parse_ActionRenameSpec(node); p.destroy_parse_node(node); return result; } inline void complete_action_rename_specification(action_rename_specification& x, const lps::specification& spec) { using namespace mcrl2::data; atermpp::aterm_appl result = lps::action_rename_specification_to_aterm(x); atermpp::aterm_appl lps_spec = lps::specification_to_aterm(spec); result = lps::detail::type_check_action_rename_specification(result, lps_spec); x = action_rename_specification(result); x.data().declare_data_specification_to_be_type_checked(); x = action_rename_specification(x.data()+spec.data(),x.action_labels(),x.rules()); x = detail::translate_user_notation_and_normalise_sorts_action_rename_spec(x); } /// \brief Parses a process specification from an input stream /// \param in An input stream /// \param alpha_reduce Indicates whether alphabet reductions need to be performed /// \return The parse result inline action_rename_specification parse_action_rename_specification(std::istream& in, const lps::specification& spec) { std::string text = utilities::read_text(in); action_rename_specification result = parse_action_rename_specification_new(text); complete_action_rename_specification(result, spec); return result; } /// \brief Parses an action rename specification. /// Parses an acion rename specification. /// If the action rename specification contains data types that are not /// present in the data specification of \p spec they are added to it. /// \param in An input stream /// \param spec A linear process specification /// \return An action rename specification inline action_rename_specification parse_action_rename_specification(const std::string& spec_string, const lps::specification& spec) { std::istringstream in(spec_string); return parse_action_rename_specification(in, spec); } /// \brief Parses a linear process specification from an input stream /// \param text An input stream containing a linear process specification /// \return The parsed specification /// \exception non_linear_process if a non-linear sub-expression is encountered. /// \exception mcrl2::runtime_error in the following cases: /// \li The number of equations is not equal to one /// \li The initial process is not a process instance, or it does not match with the equation /// \li A sequential process is found with a right hand side that is not a process instance, /// or it doesn't match the equation inline specification parse_linear_process_specification(std::istream& spec_stream) { process::process_specification pspec = mcrl2::process::parse_process_specification(spec_stream); if (!process::is_linear(pspec, true)) { throw mcrl2::runtime_error("the process specification is not linear!"); } process::detail::linear_process_conversion_traverser visitor; specification result = visitor.convert(pspec); complete_data_specification(result); return result; } /// \brief Parses a linear process specification from a string /// \param text A string containing a linear process specification /// \return The parsed specification /// \exception non_linear_process if a non-linear sub-expression is encountered. /// \exception mcrl2::runtime_error in the following cases: /// \li The number of equations is not equal to one /// \li The initial process is not a process instance, or it does not match with the equation /// \li A sequential process is found with a right hand side that is not a process instance, /// or it doesn't match the equation inline specification parse_linear_process_specification(const std::string& text) { std::istringstream stream(text); return parse_linear_process_specification(stream); } } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_PARSE_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/detail/multi_action_print.h000664 001751 001751 00000002700 12042421220 027443 0ustar00jenkinsjenkins000000 000000 // Author(s): Jan Friso Groote // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/detail/multi_action_print.h /// \brief Custom print function for multi actions #ifndef MCRL2_LPS_DETAIL_MULTI_ACTION_PRINT_H #define MCRL2_LPS_DETAIL_MULTI_ACTION_PRINT_H #include "mcrl2/lps/multi_action.h" #include "mcrl2/lps/print.h" namespace mcrl2 { namespace lps { namespace detail { /// \brief Returns a string representation of a multi action inline std::string multi_action_print(const multi_action& x) { std::string result; if (x.actions().size()==0) { result="tau"; } else { if (x.has_time() && x.actions().size()>1) { result="("; } for (action_list::const_iterator i=x.actions().begin(); i!=x.actions().end(); ++i) { result = result + lps::pp(*i); action_list::const_iterator i_next=i; i_next++; if (i_next!=x.actions().end()) { result=result + "|"; } } } if (x.has_time()) { if (x.actions().size()>1) { result=result+")"; } result=result+("@ " + data::pp(x.time())); } return result; } } // namespace detail } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_DETAIL_MULTI_ACTION_PRINT_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/detail/linear_process_conversion_traverser.h000664 001751 001751 00000033511 12042421220 033116 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/detail/linear_process_conversion_traverser.h /// \brief add your file description here. #ifndef MCRL2_LPS_DETAIL_LINEAR_PROCESS_CONVERSION_TRAVERSER_H #define MCRL2_LPS_DETAIL_LINEAR_PROCESS_CONVERSION_TRAVERSER_H #include #include "mcrl2/utilities/exception.h" #include "mcrl2/atermpp/vector.h" #include "mcrl2/lps/specification.h" #include "mcrl2/process/process_specification.h" #include "mcrl2/process/traverser.h" #include "mcrl2/process/detail/is_linear.h" namespace mcrl2 { namespace process { namespace detail { /// \brief Converts a process expression into linear process format. /// Use the \p convert member functions for this. struct linear_process_conversion_traverser: public process_expression_traverser { typedef process_expression_traverser super; using super::enter; using super::leave; using super::operator(); #if BOOST_MSVC template void operator()(Container const& a) { super::operator()(a); } #endif /// \brief The result of the conversion. lps::action_summand_vector m_action_summands; /// \brief The result of the conversion. lps::deadlock_summand_vector m_deadlock_summands; /// \brief The process equation that is checked. process_equation m_equation; /// \brief Contains intermediary results. data::variable_list m_sum_variables; /// \brief Contains intermediary results. data::assignment_list m_next_state; /// \brief Contains intermediary results. lps::multi_action m_multi_action; /// \brief Contains intermediary results. lps::deadlock m_deadlock; /// \brief True if m_deadlock was changed. bool m_deadlock_changed; /// \brief True if m_multi_action was changed. bool m_multi_action_changed; /// \brief True if m_next_state was changed. bool m_next_state_changed; /// \brief Contains intermediary results. data::data_expression m_condition; /// \brief Contains intermediary results. lps::action_summand m_action_summand; /// \brief Contains intermediary results. lps::deadlock_summand m_deadlock_summand; /// \brief Exception that is thrown to denote that the process is not linear. struct non_linear_process { process_expression expr; non_linear_process(const process_expression& p) : expr(p) {} }; /// \brief Clears the current summand void clear_summand() { m_sum_variables = data::variable_list(); m_deadlock = lps::deadlock(); m_deadlock_changed = false; m_multi_action = lps::multi_action(); m_multi_action_changed = false; m_condition = data::sort_bool::true_(); m_next_state = data::assignment_list(); m_next_state_changed = false; } /// \brief Adds a summand to the result void add_summand() { if (m_multi_action_changed) { if (m_next_state_changed) { m_action_summands.push_back(lps::action_summand(m_sum_variables, m_condition, m_multi_action, m_next_state)); clear_summand(); } else { throw mcrl2::runtime_error("Error in linear_process_conversion_traverser::convert: encountered a multi action without process reference"); } } else if (m_deadlock_changed) { m_deadlock_summands.push_back(lps::deadlock_summand(m_sum_variables, m_condition, m_deadlock)); clear_summand(); } // std::cout << "adding summand" << m_multi_action_changed << m_deadlock_changed << "\n" << lps::pp(m_summand) << std::endl; } /// \brief Visit delta node /// \return The result of visiting the node /// \param x A process expression void leave(const delta& /* x */) { m_deadlock = lps::deadlock(); m_deadlock_changed = true; // std::cout << "adding deadlock\n" << m_deadlock.to_string() << std::endl; } /// \brief Visit tau node /// \return The result of visiting the node /// \param x A process expression void leave(const tau& /* x */) { m_multi_action = lps::multi_action(); m_multi_action_changed = true; // std::cout << "adding multi action tau\n" << m_multi_action.to_string() << std::endl; } /// \brief Visit action node /// \return The result of visiting the node /// \param x A process expression /// \param l An action label /// \param v A sequence of data expressions void leave(const lps::action& x) { action a(x.label(), x.arguments()); m_multi_action = lps::multi_action(a); m_multi_action_changed = true; // std::cout << "adding multi action\n" << m_multi_action.to_string() << std::endl; } /// \brief Visit sum node /// \return The result of visiting the node /// \param x A process expression /// \param v A sequence of data variables /// \param right A process expression void leave(const sum& x) { m_sum_variables = m_sum_variables + x.bound_variables(); // std::cout << "adding sum variables\n" << data::pp(v) << std::endl; } /// \brief Visit block node /// \return The result of visiting the node /// \param x A process expression /// \param s A sequence of identifiers /// \param right A process expression void leave(const block& x) { throw non_linear_process(x); } /// \brief Visit hide node /// \return The result of visiting the node /// \param x A process expression /// \param s A sequence of identifiers /// \param right A process expression void leave(const hide& x) { throw non_linear_process(x); } /// \brief Visit rename node /// \return The result of visiting the node /// \param x A process expression /// \param r A sequence of rename expressions /// \param right A process expression void leave(const rename& x) { throw non_linear_process(x); } /// \brief Visit comm node /// \return The result of visiting the node /// \param x A process expression /// \param c A sequence of communication expressions /// \param right A process expression void leave(const comm& x) { throw non_linear_process(x); } /// \brief Visit allow node /// \return The result of visiting the node /// \param x A process expression /// \param s A sequence of multi-action names /// \param right A process expression void leave(const allow& x) { throw non_linear_process(x); } /// \brief Visit sync node /// \return The result of visiting the node /// \param x A process expression /// \param left A process expression /// \param right A process expression void operator()(const sync& x) { (*this)(x.left()); lps::multi_action l = m_multi_action; (*this)(x.right()); lps::multi_action r = m_multi_action; m_multi_action = l + r; m_multi_action_changed = true; // std::cout << "adding multi action\n" << m_multi_action.to_string() << std::endl; } /// \brief Visit at node /// \return The result of visiting the node /// \param x A process expression /// \param left A process expression /// \param d A data expression void leave(const at& x) { if (is_delta(x)) { m_deadlock.time() = x.time_stamp(); // std::cout << "adding deadlock\n" << m_deadlock.to_string() << std::endl; } else { m_multi_action.time() = x.time_stamp(); // std::cout << "adding multi action\n" << m_multi_action.to_string() << std::endl; } } /// \brief Visit seq node /// \return The result of visiting the node /// \param x A process expression /// \param left A process expression /// \param right A process expression void operator()(const seq& x) { (*this)(x.left()); // Check 1) The expression right must be a process instance or a process assignment if (is_process_instance(x.right())) { process_instance p = x.right(); // Check 2) The process equation and and the process instance must match if (!detail::check_process_instance(m_equation, p)) { std::clog << "seq right hand side: " << process::pp(x.right()) << std::endl; throw mcrl2::runtime_error("Error in linear_process_conversion_traverser::convert: seq expression encountered that does not match the process equation"); } m_next_state = data::make_assignment_list(m_equation.formal_parameters(), p.actual_parameters()); m_next_state_changed = true; } else if (is_process_instance_assignment(x.right())) { process_instance_assignment p = x.right(); // Check 2) The process equation and and the process instance assignment must match if (!detail::check_process_instance_assignment(m_equation, p)) { std::clog << "seq right hand side: " << process::pp(x.right()) << std::endl; throw mcrl2::runtime_error("Error in linear_process_conversion_traverser::convert: seq expression encountered that does not match the process equation"); } m_next_state = p.assignments(); // TODO: check if this is correct m_next_state_changed = true; } else { std::clog << "seq right hand side: " << process::pp(x.right()) << std::endl; throw mcrl2::runtime_error("Error in linear_process_conversion_traverser::convert: seq expression encountered with an unexpected right hand side"); } // std::cout << "adding next state\n" << data::pp(m_next_state) << std::endl; } /// \brief Visit if_then node /// \return The result of visiting the node /// \param x A process expression /// \param d A data expression /// \param right A process expression void leave(const if_then& x) { m_condition = x.condition(); // std::cout << "adding condition\n" << data::pp(m_condition) << std::endl; } /// \brief Visit if_then_else node /// \return The result of visiting the node /// \param x A process expression /// \param d A data expression /// \param left A process expression /// \param right A process expression void leave(const if_then_else& x) { throw non_linear_process(x); } /// \brief Visit bounded_init node /// \return The result of visiting the node /// \param x A process expression /// \param left A process expression /// \param right A process expression void leave(const bounded_init& x) { throw non_linear_process(x); } /// \brief Visit merge node /// \return The result of visiting the node /// \param x A process expression /// \param left A process expression /// \param right A process expression void leave(const merge& x) { throw non_linear_process(x); } /// \brief Visit left_merge node /// \return The result of visiting the node /// \param x A process expression /// \param left A process expression /// \param right A process expression void leave(const left_merge& x) { throw non_linear_process(x); } /// \brief Visit choice node /// \return The result of visiting the node /// \param x A process expression /// \param left A process expression /// \param right A process expression void operator()(const choice& x) { (*this)(x.left()); if (!is_choice(x.left())) { add_summand(); } (*this)(x.right()); if (!is_choice(x.right())) { add_summand(); } } /// \brief Returns true if the process equation e is linear. /// \param e A process equation void convert(const process_equation& /* e */) { clear_summand(); (*this)(m_equation.expression()); add_summand(); // needed if it is not a choice } /// \brief Converts a process_specification into a specification. /// Throws \p non_linear_process if a non-linear sub-expression is encountered. /// Throws \p mcrl2::runtime_error in the following cases: /// \li The number of equations is not equal to one /// \li The initial process is not a process instance, or it does not match with the equation /// \li A sequential process is found with a right hand side that is not a process instance, /// or it doesn't match the equation /// \param p A process specification /// \return The converted specification lps::specification convert(const process_specification& p) { m_action_summands.clear(); m_deadlock_summands.clear(); // Check 1) The number of equations must be one if (p.equations().size() != 1) { throw mcrl2::runtime_error("Error in linear_process_conversion_traverser::convert: the number of process equations is not equal to 1!"); } m_equation = p.equations().front(); lps::process_initializer proc_init; if (is_process_instance(p.init())) { process_instance init = p.init(); if (!check_process_instance(m_equation, init)) { throw mcrl2::runtime_error("Error in linear_process_conversion_traverser::convert: the initial process does not match the process equation"); } proc_init = lps::process_initializer(data::make_assignment_list(m_equation.formal_parameters(), init.actual_parameters())); } else if (is_process_instance_assignment(p.init())) { process_instance_assignment init = p.init(); if (!check_process_instance_assignment(m_equation, init)) { throw mcrl2::runtime_error("Error in linear_process_conversion_traverser::convert: the initial process does not match the process equation"); } proc_init = lps::process_initializer(init.assignments()); } else { throw mcrl2::runtime_error("Error in linear_process_conversion_traverser::convert: the initial process has an unexpected value"); } // Do the conversion convert(m_equation); lps::linear_process proc(m_equation.formal_parameters(), m_deadlock_summands, m_action_summands); return lps::specification(p.data(), p.action_labels(), p.global_variables(), proc, proc_init); } }; } // namespace detail } // namespace process } // namespace mcrl2 #endif // MCRL2_LPS_DETAIL_LINEAR_PROCESS_CONVERSION_TRAVERSER_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/detail/specification_property_map.h000664 001751 001751 00000033321 12042421220 031164 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/detail/specification_property_map.h /// \brief A property map containing properties of an LPS specification. #ifndef MCRL2_LPS_DETAIL_SPECIFICATION_PROPERTY_MAP_H #define MCRL2_LPS_DETAIL_SPECIFICATION_PROPERTY_MAP_H #include #include #include #include #include #include // #include Don't use this, it leads to stack overflows with Visual C++ 9.0 express #include #include #include #include #include "mcrl2/atermpp/aterm_access.h" #include "mcrl2/utilities/text_utility.h" #include "mcrl2/atermpp/convert.h" #include "mcrl2/data/detail/data_property_map.h" #include "mcrl2/lps/specification.h" namespace mcrl2 { namespace lps { namespace detail { /// \brief Stores the following properties of a linear process specification: /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
property description format
summand_count The number of summands NUMBER
tau_summand_count The number of tau summands NUMBER
delta_summand_count The number of delta summands NUMBER
declared_free_variables The declared free variables NAME:SORT; ... ; NAME:SORT
declared_free_variable_namesThe names of the declared free variables NAME; ... ; NAME
declared_variable_count The number of declared free variables NUMBER
used_free_variables The used free variables NAME:SORT; ... ; NAME:SORT
used_free_variables_names The names of the used free variables NAME; ... ; NAME
used_free_variable_count The number of used free variables NUMBER
process_parameters The process parameters NAME:SORT; ... ; NAME:SORT
process_parameter_names The names of the process parameters NAME; ... ; NAME
process_parameter_count The number of process parameters NUMBER
declared_action_labels The names of the declared action labels NAME; ... ; NAME
declared_action_label_count The number of declared action labels NUMBER
used_action_labels The names of the used action labels NAME; ... ; NAME
used_action_label_count The number of used action labels NUMBER
used_multi_actions The used multi-actions (sets of label names){NAME,...,NAME}; ... ; {NAME,...,NAME}
used_multi_action_count The number of used multi-actions NUMBER ///
class specification_property_map : protected mcrl2::data::detail::data_property_map< specification_property_map > { protected: // Allow base class access to protected functions friend class data::detail::data_property_map< specification_property_map >; typedef data::detail::data_property_map< specification_property_map > super; using super::print; std::string print(const action_label l) const { return core::pp(l.name()); } std::string print(const action& a) const { return lps::pp(a); } std::string print(const deadlock& x) const { return lps::pp(x); } std::string print(const multi_action& x) const { return lps::pp(x); } std::string print(const std::set >& v) const { std::set elements; for (std::set >::const_iterator i = v.begin(); i != v.end(); ++i) { elements.insert(print(*i)); } return utilities::string_join(elements, "; "); } // super class compare functions using super::compare; std::string compare_property(std::string property, std::string x, std::string y) const { if (property == "summand_count") { return compare(property, parse_unsigned_int(x), parse_unsigned_int(y)); } else if (property == "tau_summand_count") { return compare(property, parse_unsigned_int(x), parse_unsigned_int(y)); } else if (property == "delta_summand_count") { return compare(property, parse_unsigned_int(x), parse_unsigned_int(y)); } else if (property == "declared_free_variables") { return compare(property, parse_set_string(x), parse_set_string(y)); } else if (property == "declared_free_variable_names") { return compare(property, parse_set_string(x), parse_set_string(y)); } else if (property == "declared_free_variable_count") { return compare(property, parse_unsigned_int(x), parse_unsigned_int(y)); } else if (property == "used_free_variables") { return compare(property, parse_set_string(x), parse_set_string(y)); } else if (property == "used_free_variable_names") { return compare(property, parse_set_string(x), parse_set_string(y)); } else if (property == "used_free_variable_count") { return compare(property, parse_unsigned_int(x), parse_unsigned_int(y)); } else if (property == "process_parameters") { return compare(property, parse_set_string(x), parse_set_string(y)); } else if (property == "process_parameter_names") { return compare(property, parse_set_string(x), parse_set_string(y)); } else if (property == "process_parameter_count") { return compare(property, parse_unsigned_int(x), parse_unsigned_int(y)); } else if (property == "declared_action_labels") { return compare(property, parse_set_string(x), parse_set_string(y)); } else if (property == "declared_action_label_count") { return compare(property, parse_unsigned_int(x), parse_unsigned_int(y)); } else if (property == "used_action_labels") { return compare(property, parse_set_string(x), parse_set_string(y)); } else if (property == "used_action_label_count") { return compare(property, parse_unsigned_int(x), parse_unsigned_int(y)); } else if (property == "used_multi_actions") { return compare(property, parse_set_multiset_string(x), parse_set_multiset_string(y)); } else if (property == "used_multi_action_count") { return compare(property, parse_unsigned_int(x), parse_unsigned_int(y)); } return "ERROR: unknown property " + property + " encountered!"; } //--------------------------------------------// // compute functions //--------------------------------------------// // TODO: the compute functions can be combined for efficiency std::set > compute_used_multi_actions(const specification& spec) const { std::set > result; for (action_summand_vector::const_iterator i = spec.process().action_summands().begin(); i != spec.process().action_summands().end(); ++i) { action_list a = i->multi_action().actions(); std::multiset labels; for (action_list::iterator j = a.begin(); j != a.end(); ++j) { labels.insert(j->label()); } result.insert(labels); } return result; } std::set compute_used_action_labels(const specification& spec) const { std::set result; for (action_summand_vector::const_iterator i = spec.process().action_summands().begin(); i != spec.process().action_summands().end(); ++i) { action_list a = i->multi_action().actions(); for (action_list::iterator j = a.begin(); j != a.end(); ++j) { result.insert(j->label()); } } return result; } size_t compute_tau_summand_count(const specification& spec) const { size_t result = 0; const action_summand_vector& summands = spec.process().action_summands(); for (action_summand_vector::const_iterator i = summands.begin(); i != summands.end(); ++i) { if (i->is_tau()) { result++; } } return result; } std::set compute_used_free_variables(const specification& spec) const { return lps::find_free_variables(spec.process()); } public: /// \brief Constructor. /// The strings may appear in a random order, and not all of them need to be present specification_property_map(const std::string& text) : super(text) {} /// \brief Constructor /// Initializes the specification_property_map with a linear process specification specification_property_map(const specification& spec) { size_t summand_count = spec.process().summand_count(); size_t tau_summand_count = compute_tau_summand_count(spec); size_t delta_summand_count = spec.process().deadlock_summands().size(); std::set declared_free_variables = spec.global_variables(); std::set used_free_variables = compute_used_free_variables(spec); std::set process_parameters = atermpp::convert >(spec.process().process_parameters()); std::set declared_action_labels = atermpp::convert >(spec.action_labels()); std::set used_action_labels = compute_used_action_labels(spec); std::set > used_multi_actions = compute_used_multi_actions(spec); m_data["summand_count" ] = print(summand_count); m_data["tau_summand_count" ] = print(tau_summand_count); m_data["delta_summand_count" ] = print(delta_summand_count); m_data["declared_free_variables" ] = print(declared_free_variables, false); m_data["declared_free_variable_names"] = print(names(declared_free_variables), false); m_data["declared_free_variable_count"] = print(declared_free_variables.size()); m_data["used_free_variables" ] = print(used_free_variables, false); m_data["used_free_variable_names" ] = print(names(used_free_variables), false); m_data["used_free_variable_count" ] = print(used_free_variables.size()); m_data["process_parameters" ] = print(process_parameters, false); m_data["process_parameter_names" ] = print(names(process_parameters), false); m_data["process_parameter_count" ] = print(process_parameters.size()); m_data["declared_action_labels" ] = print(declared_action_labels, false); m_data["declared_action_label_count" ] = print(declared_action_labels.size()); m_data["used_action_labels" ] = print(used_action_labels, false); m_data["used_action_label_count" ] = print(used_action_labels.size()); m_data["used_multi_actions" ] = print(used_multi_actions); m_data["used_multi_action_count" ] = print(used_multi_actions.size()); } using super::to_string; using super::data; using super::operator[]; std::string compare(const specification_property_map& other) const { return super::compare(other); } /// \brief Returns a textual overview of some properties of an LPS std::string info() const { std::ostringstream out; out << "Number of summands : " << (*this)["summand_count" ] << "\n"; out << "Number of tau-summands : " << (*this)["tau_summand_count" ] << "\n"; out << "Number of declared global variables : " << (*this)["declared_free_variable_count"] << "\n"; out << "Number of process parameters : " << (*this)["process_parameter_count" ] << "\n"; out << "Number of declared action labels : " << (*this)["declared_action_label_count" ] << "\n"; out << "Number of used actions : " << (*this)["used_action_label_count" ] << "\n"; out << "Number of used multi-actions : " << (*this)["used_multi_action_count" ] << "\n"; return out.str(); } }; } // namespace detail } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_DETAIL_SPECIFICATION_PROPERTY_MAP_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/detail/lps_algorithm.h000664 001751 001751 00000011276 12042421220 026414 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/detail/lps_algorithm.h /// \brief Add your file description here. #ifndef MCRL2_LPS_DETAIL_LPS_ALGORITHM_H #define MCRL2_LPS_DETAIL_LPS_ALGORITHM_H #include #include #include #include #include #include "mcrl2/atermpp/vector.h" #include "mcrl2/data/rewriter.h" #include "mcrl2/lps/specification.h" #include "mcrl2/lps/rewrite.h" #include "mcrl2/lps/replace.h" #include "mcrl2/lps/remove.h" #include "mcrl2/lps/detail/instantiate_global_variables.h" namespace mcrl2 { namespace lps { namespace detail { /// \brief Algorithm class for algorithms on linear process specifications. class lps_algorithm { protected: /// \brief The specification that is processed by the algorithm specification& m_spec; void sumelm_find_variables(const action_summand& s, std::set& result) const { std::set tmp; tmp = data::find_free_variables(s.condition()); result.insert(tmp.begin(), tmp.end()); tmp = lps::find_free_variables(s.multi_action()); result.insert(tmp.begin(), tmp.end()); tmp = data::find_free_variables(s.assignments()); result.insert(tmp.begin(), tmp.end()); } void sumelm_find_variables(const deadlock_summand& s, std::set& result) const { std::set tmp; tmp = data::find_free_variables(s.condition()); result.insert(tmp.begin(), tmp.end()); tmp = lps::find_free_variables(s.deadlock()); result.insert(tmp.begin(), tmp.end()); } template void remove_unused_summand_variables(SummandType& summand_) { data::variable_vector new_summation_variables; std::set occurring_vars; sumelm_find_variables(summand_, occurring_vars); std::set summation_variables(atermpp::convert >(summand_.summation_variables())); std::set_intersection(summation_variables.begin(), summation_variables.end(), occurring_vars.begin(), occurring_vars.end(), std::inserter(new_summation_variables, new_summation_variables.end())); summand_.summation_variables() = atermpp::convert(new_summation_variables); } public: /// \brief Constructor lps_algorithm(specification& spec) : m_spec(spec) {} /// \brief Flag for verbose output bool verbose() const { return mCRL2logEnabled(log::verbose); } /// \brief Applies the next state substitution to the variable v. data::data_expression next_state(const action_summand& s, const data::variable& v) const { const data::assignment_list& a = s.assignments(); for (data::assignment_list::const_iterator i = a.begin(); i != a.end(); ++i) { if (i->lhs() == v) { return i->rhs(); } } return v; // no assignment to v found, so return v itself } /// \brief Attempts to eliminate the free variables of the specification, by substituting /// a constant value for them. If no constant value is found for one of the variables, /// an exception is thrown. void instantiate_free_variables() { lps::detail::instantiate_global_variables(m_spec); } /// \brief Removes formal parameters from the specification void remove_parameters(const std::set& to_be_removed) { lps::remove_parameters(m_spec, to_be_removed); } /// \brief Removes parameters with a singleton sort void remove_singleton_sorts() { lps::remove_singleton_sorts(m_spec); } /// \brief Removes summands with condition equal to false void remove_trivial_summands() { lps::remove_trivial_summands(m_spec); } /// \brief Removes unused summand variables. void remove_unused_summand_variables() { action_summand_vector& v = m_spec.process().action_summands(); std::for_each(v.begin(), v.end(), boost::bind(&lps_algorithm::remove_unused_summand_variables, this, _1)); deadlock_summand_vector& w = m_spec.process().deadlock_summands(); std::for_each(w.begin(), w.end(), boost::bind(&lps_algorithm::remove_unused_summand_variables, this, _1)); } }; } // namespace detail } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_DETAIL_LPS_ALGORITHM_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/detail/instantiate_global_variables.h000664 001751 001751 00000003252 12042421220 031436 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/detail/instantiate_global_variables.h /// \brief add your file description here. #ifndef MCRL2_LPS_DETAIL_INSTANTIATE_GLOBAL_VARIABLES_H #define MCRL2_LPS_DETAIL_INSTANTIATE_GLOBAL_VARIABLES_H #include "mcrl2/data/representative_generator.h" #include "mcrl2/lps/specification.h" #include "mcrl2/lps/replace.h" #include "mcrl2/lps/remove.h" namespace mcrl2 { namespace lps { namespace detail { inline void instantiate_global_variables(specification& spec) { data::mutable_map_substitution<> sigma; data::representative_generator default_expression_generator(spec.data()); std::set to_be_removed; const atermpp::set& v = spec.global_variables(); for (atermpp::set::const_iterator i = v.begin(); i != v.end(); ++i) { data::data_expression d = default_expression_generator(i->sort()); if (d == data::data_expression()) { throw mcrl2::runtime_error("Error in lps::instantiate_global_variables: could not instantiate " + data::pp(*i)); } sigma[*i] = d; to_be_removed.insert(*i); } lps::replace_free_variables(spec.process(), sigma); spec.initial_process() = lps::replace_free_variables(spec.initial_process(), sigma); spec.global_variables().clear(); } } // namespace detail } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_DETAIL_INSTANTIATE_GLOBAL_VARIABLES_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/detail/test_input.h000664 001751 001751 00000034547 12042421220 025754 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/detail/test_input.h /// \brief This file contains some specifications used for testing. #ifndef MCRL2_LPS_DETAIL_TEST_INPUT_H #define MCRL2_LPS_DETAIL_TEST_INPUT_H #include namespace mcrl2 { namespace lps { namespace detail { inline std::string ABP_SPECIFICATION() { return "% This file contains the alternating bit protocol, as described in W.J. \n" "% Fokkink, J.F. Groote and M.A. Reniers, Modelling Reactive Systems. \n" "% \n" "% The only exception is that the domain D consists of two data elements to \n" "% facilitate simulation. \n" " \n" "sort \n" " D = struct d1 | d2; \n" " Error = struct e; \n" " \n" "act \n" " r1,s4: D; \n" " s2,r2,c2: D # Bool; \n" " s3,r3,c3: D # Bool; \n" " s3,r3,c3: Error; \n" " s5,r5,c5: Bool; \n" " s6,r6,c6: Bool; \n" " s6,r6,c6: Error; \n" " i; \n" " \n" "proc \n" " S(b:Bool) = sum d:D. r1(d).T(d,b); \n" " T(d:D,b:Bool) = s2(d,b).(r6(b).S(!b)+(r6(!b)+r6(e)).T(d,b)); \n" " \n" " R(b:Bool) = sum d:D. r3(d,b).s4(d).s5(b).R(!b)+ \n" " (sum d:D.r3(d,!b)+r3(e)).s5(!b).R(b); \n" " \n" " K = sum d:D,b:Bool. r2(d,b).(i.s3(d,b)+i.s3(e)).K; \n" " \n" " L = sum b:Bool. r5(b).(i.s6(b)+i.s6(e)).L; \n" " \n" "init \n" " allow({r1,s4,c2,c3,c5,c6,i}, \n" " comm({r2|s2->c2, r3|s3->c3, r5|s5->c5, r6|s6->c6}, \n" " S(true) || K || L || R(true) \n" " ) \n" " ); \n" ; } inline std::string DINING3_SPECIFICATION() { return "% This is a specification of the dining philosophers problem \n" "% for 3 philosophers. \n" " \n" "sort Phil = struct p1 | p2 | p3; \n" " Fork = struct f1 | f2 | f3; \n" " \n" "map lf, rf: Phil -> Fork; \n" "eqn lf(p1) = f1; \n" " lf(p2) = f2; \n" " lf(p3) = f3; \n" " rf(p1) = f3; \n" " rf(p2) = f1; \n" " rf(p3) = f2; \n" " \n" "act get, put, up, down, lock, free: Phil # Fork; \n" " eat: Phil; \n" " \n" "proc P_Phil(p: Phil) = \n" " %The following line implements the expression (get(p,lf(p))||get(p,rf(p))) \n" " (get(p,lf(p)).get(p,rf(p)) + get(p,rf(p)).get(p,lf(p)) + get(p,lf(p))|get(p,rf(p))) \n" " . eat(p) . \n" " %The following line implements the expression (put(p,lf(p))||put(p,rf(p))) \n" " (put(p,lf(p)).put(p,rf(p)) + put(p,rf(p)).put(p,lf(p)) + put(p,lf(p))|put(p,rf(p))) \n" " . P_Phil(p); \n" " P_Fork(f: Fork) = sum p:Phil. up(p,f) . down(p,f) . P_Fork(f); \n" " \n" "init block( { get, put, up, down }, \n" " comm( { get|up->lock, put|down->free }, \n" " P_Fork(f1) || P_Fork(f2) || P_Fork(f3) || \n" " P_Phil(p1) || P_Phil(p2) || P_Phil(p3) \n" " )); \n" ; } inline std::string ONE_BIT_SLIDING_WINDOW_SPECIFICATION() { return "% This file describes the onebit sliding window protocol as documented \n" "% M.A. Bezem and J.F. Groote. A correctness proof of a one bit sliding \n" "% window protocol in muCRL. The Computer Journal, 37(4): 289-307, 1994. \n" "% This sliding window protocol is a bidirectional sliding window protocol \n" "% with piggy backing, where the window sizes at the receiving and \n" "% sending side have size 1. The behaviour of this sliding window protocol \n" "% is that of two bidirectional buffers sending data from channel ra to \n" "% sb, and from rc to sd. Both buffers have capacity 2. \n" "% The external behaviour of the onebit protocol is rather complex. \n" "% However, making only the behaviour visible at gates ra and sb reduced \n" "% modulo branching bisimulation clearly shows the behaviour of \n" "% a buffer of capacity 2. \n" "% \n" "% Jan Friso Groote, translated from muCRL 30/12/2006 \n" " \n" "sort Bit = struct e0 | e1; \n" " D= struct d1; \n" " Frame=struct frame(dat:D,bit1:Bit,bit2:Bit); \n" " Status=struct read?eq_read | choice?eq_choice | del?eq_del; \n" " \n" "map inv:Bit-> Bit; \n" "eqn inv(e0)=e1; \n" " inv(e1)=e0; \n" " \n" "act r,w,rc,sd:D; \n" " rcl,scl,i_del,i_lost,ccl; \n" " r1,s1,c1,s2,r2,c2,s4,r4,c4:Frame; \n" " \n" "proc S(ready:Bool,rec:Bool,sts:Bool,d:D,e:D,p:Bit,q:Bit)= \n" " ready -> sum d:D.r(d).S(false,rec,false,d,e,inv(p),q) + \n" " !rec -> w(e).S(ready,true,sts,d,e,p,q) + \n" " rcl.S(ready,rec,false,d,e,p,q)+ \n" " sum f:D,b1:Bit,b2:Bit. \n" " r4(frame(f,b1,b2)). \n" " (rec && b1==inv(q)) -> S(b2==p,false,sts,d,f,p,inv(q)) \n" " <> S(b2==p,rec,sts,d,e,p,q) + \n" " !sts -> s1(frame(d,p,q)).S(ready,rec,true,d,e,p,q) + \n" " delta; \n" " \n" "proc Tim= scl.Tim; \n" " \n" "proc C(f:Frame,st:Status)= \n" " eq_read(st) -> sum f:Frame.r1(f).C(f,choice)<>delta+ \n" " eq_choice(st) -> (i_del.C(f,del)+i_lost.C(f,read))<>delta+ \n" " eq_del(st) -> s2(f).C(f,read)<>delta ; \n" " \n" "init hide ({c4,c2,ccl,c1,i_del,i_lost}, \n" " allow({c1,ccl,c2,c4,i_del,i_lost,r,w,rc,sd}, \n" " comm({r2|s2->c2,r4|s4->c4}, \n" " rename({w->sd}, \n" " allow({c1,ccl,r,w,s2,r4,i_del,i_lost}, \n" " comm({rcl|scl->ccl,r1|s1->c1}, \n" " S(true,true,true,d1,d1,e0,e0)|| \n" " Tim|| \n" " C(frame(d1,e0,e0),read))))|| \n" " rename({r->rc,s2->s4,r4->r2}, \n" " allow({c1,ccl,r,w,s2,r4,i_del,i_lost}, \n" " comm({rcl|scl->ccl,r1|s1->c1}, \n" " S(true,true,true,d1,d1,e0,e0)|| \n" " Tim|| \n" " C(frame(d1,e0,e0) ,read))))))); \n" ; } inline std::string LINEAR_ABP_SPECIFICATION() { return "sort D = struct d1 | d2;\n" " Error = struct e;\n" "act r1,s4: D;\n" " s2,r2,c2,s3,r3,c3: D # Bool;\n" " s3,r3,c3: Error;\n" " s5,r5,c5,s6,r6,c6: Bool;\n" " s6,r6,c6: Error;\n" " i;\n" "proc P(s30_S: Pos, d_S: D, b_S: Bool, s31_K: Pos, d_K: D, b_K: Bool, s32_L: Pos, b_L: Bool, s33_R: Pos, d_R: D, b_R: Bool) =\n" " sum d0_S: D.\n" " (s30_S == 1) ->\n" " r1(d0_S) .\n" " P(s30_S = 2, d_S = d0_S)\n" " + ((s31_K == 3 && s33_R == 1) && !b_R == b_K) ->\n" " c3(d_K, !b_R) .\n" " P(s31_K = 1, d_K = d1, b_K = true, s33_R = 4, d_R = d1)\n" " + ((s31_K == 3 && s33_R == 1) && b_R == b_K) ->\n" " c3(d_K, b_R) .\n" " P(s31_K = 1, d_K = d1, b_K = true, s33_R = 2, d_R = d_K)\n" " + (s31_K == 4 && s33_R == 1) ->\n" " c3(e) .\n" " P(s31_K = 1, d_K = d1, b_K = true, s33_R = 4, d_R = d1)\n" " + (s32_L == 2) ->\n" " i .\n" " P(s32_L = 4, b_L = true)\n" " + (s32_L == 2) ->\n" " i .\n" " P(s32_L = 3)\n" " + (s33_R == 2) ->\n" " s4(d_R) .\n" " P(s33_R = 3, d_R = d1)\n" " + (s32_L == 1 && s33_R == 4) ->\n" " c5(!b_R) .\n" " P(s32_L = 2, b_L = !b_R, s33_R = 1, d_R = d1)\n" " + (s32_L == 1 && s33_R == 3) ->\n" " c5(b_R) .\n" " P(s32_L = 2, b_L = b_R, s33_R = 1, d_R = d1, b_R = !b_R)\n" " + (s31_K == 2) ->\n" " i .\n" " P(s31_K = 3)\n" " + (s31_K == 2) ->\n" " i .\n" " P(s31_K = 4, d_K = d1, b_K = true)\n" " + (s30_S == 3 && s32_L == 4) ->\n" " c6(e) .\n" " P(s30_S = 2, s32_L = 1, b_L = true)\n" " + ((s30_S == 3 && s32_L == 3) && !b_S == b_L) ->\n" " c6(!b_S) .\n" " P(s30_S = 2, s32_L = 1, b_L = true)\n" " + ((s30_S == 3 && s32_L == 3) && b_S == b_L) ->\n" " c6(b_S) .\n" " P(s30_S = 1, d_S = d1, b_S = !b_S, s32_L = 1, b_L = true)\n" " + (s30_S == 2 && s31_K == 1) ->\n" " c2(d_S, b_S) .\n" " P(s30_S = 3, s31_K = 2, d_K = d_S, b_K = b_S)\n" " + delta;\n" "init P(1, d1, true, 1, d1, true, 1, true, 1, d1, true);\n" ; } } // namespace detail } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_DETAIL_TEST_INPUT_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/detail/lps_parameter_remover.h000664 001751 001751 00000010062 12042421220 030135 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/detail/lps_parameter_remover.h /// \brief add your file description here. // This is to deal with circular header file dependencies #ifndef MCRL2_LPS_SPECIFICATION_H #include "mcrl2/lps/specification.h" #endif #ifndef MCRL2_LPS_DETAIL_LPS_PARAMETER_REMOVER_H #define MCRL2_LPS_DETAIL_LPS_PARAMETER_REMOVER_H #include #include #include "mcrl2/data/detail/assignment_functional.h" namespace mcrl2 { namespace lps { namespace detail { /// \brief Function object for removing parameters from LPS data types. /// These parameters can be either process parameters or free variables. /// Assignments to these parameters are removed as well. template struct lps_parameter_remover { const SetContainer& to_be_removed; lps_parameter_remover(const SetContainer& to_be_removed_) : to_be_removed(to_be_removed_) {} /// \brief Removes parameters from a set container. template void remove_set_container(SetContainer1& c) const { for (typename SetContainer::const_iterator i = to_be_removed.begin(); i != to_be_removed.end(); ++i) { c.erase(*i); } } /// \brief Removes parameters from a list of variables. data::variable_list remove_list_copy(const data::variable_list& l) const { std::vector result; for (data::variable_list::const_iterator i = l.begin(); i != l.end(); ++i) { if (to_be_removed.find(*i) == to_be_removed.end()) { result.push_back(*i); } } return data::variable_list(result.begin(), result.end()); } /// \brief Removes parameters from a list of assignments. /// Assignments to removed parameters are removed. data::assignment_list remove_list_copy(const data::assignment_list& l) const { // TODO: make this implementation more efficient std::vector a(l.begin(), l.end()); a.erase(std::remove_if(a.begin(), a.end(), data::detail::has_left_hand_side_in(to_be_removed)), a.end()); return data::assignment_list(a.begin(), a.end()); } /// \brief Removes parameters from the elements of a term list template void remove_list(TermList& l) const { l = remove_list_copy(l); } /// \brief Removes parameters from the elements of a container template void remove_container(Container& c) const { for (typename Container::iterator i = c.begin(); i != c.end(); ++i) { remove(*i); } } /// \brief Removes parameters from a summand /// \param s A summand void remove(action_summand& s) const { remove_list(s.assignments()); } /// \brief Removes parameters from a process_initializer /// \param s A process_initializer void remove(process_initializer& i) const { i = process_initializer(remove_list_copy(i.assignments())); } /// \brief Removes parameters from a linear_process /// \param s A linear_process void remove(linear_process& p) const { remove_list(p.process_parameters()); remove_container(p.action_summands()); } /// \brief Removes parameters from a linear process specification /// \param spec A linear process specification void remove(specification& spec) const { remove(spec.process()); remove(spec.initial_process()); remove_set_container(spec.global_variables()); } template void operator()(Term& t) { remove(t); } }; /// \brief Utility function to create an lps_parameter_remover. template lps_parameter_remover make_lps_parameter_remover(const SetContainer& to_be_removed) { return lps_parameter_remover(to_be_removed); } } // namespace detail } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_DETAIL_LPS_PARAMETER_REMOVER_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/detail/action_utility.h000664 001751 001751 00000005210 12042421220 026577 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/detail/action_utility.h /// \brief Add your file description here. #ifndef MCRL2_LPS_DETAIL_ACTION_UTILITY_H #define MCRL2_LPS_DETAIL_ACTION_UTILITY_H #include #include "mcrl2/lps/action.h" #include "mcrl2/data/detail/data_utility.h" namespace mcrl2 { namespace lps { namespace detail { /// \brief Returns true if the sorts of the given actions are contained in sorts. /// \param actions A sequence of actions /// \param sorts A set of sort expressions /// \return True if the sorts of the given actions are contained in sorts. inline bool check_action_sorts(action_list actions, const std::set& sorts) { for (action_list::iterator i = actions.begin(); i != actions.end(); ++i) { const data::sort_expression_list& s = i->label().sorts(); for (data::sort_expression_list::const_iterator j = s.begin(); j != s.end(); ++j) { if (!data::detail::check_sort(*j, sorts)) { return false; } } } return true; } /// \brief Returns true if the labels of the given actions are contained in labels. /// \param actions A sequence of actions /// \param labels A set of action labels /// \return True if the labels of the given actions are contained in labels. inline bool check_action_labels(action_list actions, const std::set& labels) { for (action_list::iterator i = actions.begin(); i != actions.end(); ++i) { if (labels.find(i->label()) == labels.end()) { return false; } } return true; } /// \brief Returns true if the sorts of the given action labels are contained in sorts. /// \param action_labels A sequence of action labels /// \param sorts A set of sort expressions /// \return True if the sorts of the given action labels are contained in sorts. inline bool check_action_label_sorts(action_label_list action_labels, const std::set& sorts) { for (action_label_list::iterator i = action_labels.begin(); i != action_labels.end(); ++i) { data::sort_expression_list i_sorts(i->sorts()); for (data::sort_expression_list::const_iterator j = i_sorts.begin(); j != i_sorts.end(); ++j) { if (!data::detail::check_sort(*j, sorts)) { return false; } } } return true; } } // namespace detail } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_DETAIL_ACTION_UTILITY_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/detail/make_timed_lps.h000664 001751 001751 00000005534 12042421220 026525 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/detail/make_timed_lps.h /// \brief add your file description here. #ifndef MCRL2_LPS_DETAIL_MAKE_TIMED_LPS_H #define MCRL2_LPS_DETAIL_MAKE_TIMED_LPS_H #include #include "mcrl2/data/real.h" #include "mcrl2/data/set_identifier_generator.h" #include "mcrl2/lps/linear_process.h" namespace mcrl2 { namespace lps { namespace detail { /// \brief Adds a time parameter t to s if needed and returns the result. The time t /// is chosen such that it doesn't appear in context. template struct make_timed_lps_summand { IdentifierGenerator& m_generator; make_timed_lps_summand(IdentifierGenerator& generator) : m_generator(generator) {} /// \brief Adds time to the summand s (either an action or a deadlock summand) /// \param s An action summand void operator()(deadlock_summand& s) const { if (!s.deadlock().has_time()) { data::variable t(m_generator("T"), data::sort_real::real_()); s.deadlock().time() = t; data::variable_vector v = atermpp::convert(s.summation_variables()); v.push_back(t); s.summation_variables() = atermpp::convert(v); } } /// \brief Adds time to the summand s (either an action or a deadlock summand) /// \param s An action summand void operator()(action_summand& s) const { if (!s.multi_action().has_time()) { data::variable t(m_generator("T"), data::sort_real::real_()); s.multi_action().time() = t; data::variable_vector v = atermpp::convert(s.summation_variables()); v.push_back(t); s.summation_variables() = atermpp::convert(v); } } }; /// \brief Adds time parameters to the lps if needed and returns the result. /// The times are chosen such that they don't appear in context. /// \param lps A linear process /// \param context A term /// \return A timed linear process inline void make_timed_lps(linear_process& lps, const std::set& context) { data::set_identifier_generator generator; generator.add_identifiers(context); make_timed_lps_summand f(generator); for (action_summand_vector::iterator i = lps.action_summands().begin(); i != lps.action_summands().end(); ++i) { f(*i); } for (deadlock_summand_vector::iterator i = lps.deadlock_summands().begin(); i != lps.deadlock_summands().end(); ++i) { f(*i); } } } // namespace detail } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_DETAIL_MAKE_TIMED_LPS_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/detail/lps_well_typed_checker.h000664 001751 001751 00000033217 12042421220 030261 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/detail/lps_well_typed_checker.h /// \brief add your file description here. #ifndef MCRL2_LPS_DETAIL_LPS_WELL_TYPED_CHECKER_H #define MCRL2_LPS_DETAIL_LPS_WELL_TYPED_CHECKER_H #include #include "mcrl2/data/detail/sequence_algorithm.h" #include "mcrl2/lps/specification.h" #include "mcrl2/lps/detail/action_utility.h" namespace mcrl2 { namespace lps { template std::string pp(const T&); namespace detail { /// \brief Function object for applying a substitution to LPS data types. struct lps_well_typed_checker { /// \brief Checks if the sort of t has type real bool check_time(const data::data_expression& t, const std::string& type) const { if (!data::sort_real::is_real(t.sort())) { mCRL2log(log::error) << "is_well_typed(" << type << ") failed: time " << data::pp(t) << " doesn't have sort real." << std::endl; return false; } return true; } /// \brief Checks if the sort of t has type bool bool check_condition(const data::data_expression& t, const std::string& type) const { if (!data::sort_bool::is_bool(t.sort())) { mCRL2log(log::error) << "is_well_typed(" << type << ") failed: condition " << data::pp(t) << " doesn't have sort bool." << std::endl; return false; } return true; } /// \brief Checks if the assignments are well typed and have unique left hand sides bool check_assignments(const data::assignment_list& l, const std::string& type) const { if (!is_well_typed_container(l)) { mCRL2log(log::error) << "is_well_typed(" << type << ") failed: the assignments " << data::pp(l) << " are not well typed." << std::endl; return false; } if (data::detail::sequence_contains_duplicates( boost::make_transform_iterator(l.begin(), data::detail::assignment_lhs()), boost::make_transform_iterator(l.end() , data::detail::assignment_lhs()) ) ) { mCRL2log(log::error) << "is_well_typed(" << type << ") failed: data assignments " << data::pp(l) << " don't have unique left hand sides." << std::endl; return false; } return true; } /// \brief Checks well typedness of the elements of a container template bool is_well_typed_container(const Container& c) const { for (typename Container::const_iterator i = c.begin(); i != c.end(); ++i) { if (!is_well_typed(*i)) { return false; } } return true; } /// \brief Checks well typedness of a sort expression /// \param d A sort expression bool is_well_typed(const data::sort_expression&) const { return true; } /// \brief Checks well typedness of a variable /// \param d A variable bool is_well_typed(const data::variable&) const { return true; } /// \brief Checks well typedness of a data expression /// \param d A data expression bool is_well_typed(const data::data_expression&) const { return true; } /// \brief Traverses an assignment /// \param a An assignment bool is_well_typed(const data::assignment& a) const { if (a.lhs().sort() != a.rhs().sort()) { std::clog << "is_well_typed(data_assignment) failed: the left and right hand sides " << data::pp(a.lhs()) << " and " << data::pp(a.rhs()) << " have different sorts." << std::endl; return false; } return true; } /// \brief Traverses an action label bool is_well_typed(const action_label&) const { return true; } /// \brief Traverses an action /// \param a An action bool is_well_typed(const action&) const { return true; } /// \brief Checks well typedness of a deadlock /// \param d A deadlock /// \return Returns true if ///
    ///
  • the (optional) time has sort Real
    • ///
bool is_well_typed(const deadlock& d) const { if (d.has_time()) { check_time(d.time(), "deadlock"); } return true; } /// \brief Checks well typedness of a multi-action /// \param a A multi-action /// \return Returns true if ///
    ///
  • the (optional) time has sort Real
    • ///
bool is_well_typed(const multi_action& a) const { if (a.has_time()) { check_time(a.time(), "deadlock"); } return true; } /// \brief Checks well typedness of a summand /// \param s An action summand bool is_well_typed(const action_summand& s) const { if (!data::detail::unique_names(s.summation_variables())) { mCRL2log(log::error) << "is_well_typed(action_summand) failed: summation variables " << data::pp(s.summation_variables()) << " don't have unique names." << std::endl; return false; } if (!check_condition(s.condition(), "action_summand")) { return false; } if (!is_well_typed(s.multi_action())) { return false; } if (!check_assignments(s.assignments(), "action_summand")) { return false; } return true; } /// \brief Checks well typedness of a summand /// \param s A summand bool is_well_typed(const deadlock_summand& s) const { if (!check_condition(s.condition(), "deadlock_summand")) { return false; } if (!is_well_typed(s.deadlock())) { return false; } return true; } /// \brief Checks well typedness of a process_initializer /// \param s A process_initializer ///
    ///
  • the left hand sides of the data assignments are unique
    • ///
bool is_well_typed(const process_initializer& i) const { if (!check_assignments(i.assignments(), "process_initializer")) { return false; } return true; } /// \brief Checks well typedness of a linear process /// \param p A linear_process /// \return True if ///
    ///
  • the process parameters have unique names
    • ///
  • process parameters and summation variables have different names
    • ///
  • the left hand sides of the assignments of summands are contained in the process parameters
    • ///
  • the summands are well typed
    • ///
bool is_well_typed(const linear_process& p) const { // check 2) if (!data::detail::unique_names(p.process_parameters())) { mCRL2log(log::error) << "is_well_typed(linear_process) failed: process parameters " << data::pp(p.process_parameters()) << " don't have unique names." << std::endl; return false; } // check 4) std::set names; for (data::variable_list::const_iterator i = p.process_parameters().begin(); i != p.process_parameters().end(); ++i) { names.insert(i->name()); } for (action_summand_vector::const_iterator i = p.action_summands().begin(); i != p.action_summands().end(); ++i) { if (!data::detail::check_variable_names(i->summation_variables(), names)) { mCRL2log(log::error) << "is_well_typed(linear_process) failed: some of the names of the summation variables " << data::pp(i->summation_variables()) << " also appear as process parameters." << std::endl; return false; } } // check 5) for (action_summand_vector::const_iterator i = p.action_summands().begin(); i != p.action_summands().end(); ++i) { if (!data::detail::check_assignment_variables(i->assignments(), p.process_parameters())) { mCRL2log(log::error) << "is_well_typed(linear_process) failed: some left hand sides of the assignments " << data::pp(i->assignments()) << " do not appear as process parameters." << std::endl; return false; } } // check 6) if (!is_well_typed_container(p.action_summands())) { return false; } if (!is_well_typed_container(p.deadlock_summands())) { return false; } return true; } /// \brief Checks well typedness of a linear process specification /// \param spec A linear process specification /// \return True if ///
    ///
  • the sorts occurring in the summation variables are declared in the data specification
    • ///
  • the sorts occurring in the process parameters are declared in the data specification
    • ///
  • the sorts occurring in the free variables are declared in the data specification
    • ///
  • the sorts occurring in the action labels are declared in the data specification
    • ///
  • the action labels occurring in the process are contained in action_labels()
    • ///
  • the process is well typed
    • ///
  • the data specification is well typed
    • ///
  • the initial process is well typed
    • ///
  • the free variables occurring in the linear process are declared in the global variable specification
    • ///
  • the free variables occurring in the initial process are declared in the global variable specification
    • ///
  • the global variables have unique names
    • ///
bool is_well_typed(const specification& spec) const { std::set declared_sorts = data::detail::make_set(spec.data().sorts()); std::set declared_labels = data::detail::make_set(spec.action_labels()); const action_summand_vector& action_summands = spec.process().action_summands(); // check 1) for (action_summand_vector::const_iterator i = action_summands.begin(); i != action_summands.end(); ++i) { if (!(data::detail::check_variable_sorts(i->summation_variables(), declared_sorts))) { mCRL2log(log::error) << "is_well_typed(specification) failed: some of the sorts of the summation variables " << data::pp(i->summation_variables()) << " are not declared in the data specification " << data::pp(spec.data().sorts()) << std::endl; return false; } } // check 2) if (!(data::detail::check_variable_sorts(spec.process().process_parameters(), declared_sorts))) { mCRL2log(log::error) << "is_well_typed(specification) failed: some of the sorts of the process parameters " << data::pp(spec.process().process_parameters()) << " are not declared in the data specification " << data::pp(spec.data().sorts()) << std::endl; return false; } // check 3) if (!(data::detail::check_variable_sorts(spec.global_variables(), declared_sorts))) { mCRL2log(log::error) << "is_well_typed(specification) failed: some of the sorts of the free variables " << data::pp(spec.global_variables()) << " are not declared in the data specification " << data::pp(spec.data().sorts()) << std::endl; return false; } // check 4) if (!(detail::check_action_label_sorts(spec.action_labels(), declared_sorts))) { mCRL2log(log::error) << "is_well_typed(specification) failed: some of the sorts occurring in the action labels " << lps::pp(spec.action_labels()) << " are not declared in the data specification " << data::pp(spec.data().sorts()) << std::endl; return false; } // check 5) for (action_summand_vector::const_iterator i = action_summands.begin(); i != action_summands.end(); ++i) { if (!(detail::check_action_labels(i->multi_action().actions(), declared_labels))) { mCRL2log(log::error) << "is_well_typed(specification) failed: some of the labels occurring in the actions " << lps::pp(i->multi_action().actions()) << " are not declared in the action specification " << lps::pp(spec.action_labels()) << std::endl; return false; } } if (!is_well_typed(spec.process())) { return false; } if (!spec.data().is_well_typed()) { return false; } if (!is_well_typed(spec.initial_process())) { return false; } std::set declared_free_variables = spec.global_variables(); std::set occ1 = lps::find_free_variables(spec.process()); std::set occ2 = lps::find_free_variables(spec.initial_process()); std::set occurring_free_variables = occ1; occurring_free_variables.insert(occ2.begin(), occ2.end()); if (!(std::includes(declared_free_variables.begin(), declared_free_variables.end(), occurring_free_variables.begin(), occurring_free_variables.end() ) )) { mCRL2log(log::error) << "is_well_typed(specification) failed: some of the free variables were not declared\n"; mCRL2log(log::error) << "declared global variables: " << data::pp(declared_free_variables) << std::endl; mCRL2log(log::error) << "occurring free variables: " << data::pp(occurring_free_variables) << std::endl; return false; } // check 3) if (!data::detail::unique_names(atermpp::convert(spec.global_variables()))) { mCRL2log(log::error) << "is_well_typed(specification) failed: global variables " << data::pp(atermpp::convert(spec.global_variables())) << " don't have unique names." << std::endl; return false; } return true; } template bool operator()(const Term& t) const { return is_well_typed(t); } }; } // namespace detail /// \brief Checks well typedness of an LPS object. template bool is_well_typed(const Object& o) { lps::detail::lps_well_typed_checker checker; return checker(o); } } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_DETAIL_LPS_WELL_TYPED_CHECKER_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/deadlock.h000664 001751 001751 00000006064 12042421220 024053 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/deadlock.h /// \brief add your file description here. #ifndef MCRL2_LPS_DEADLOCK_H #define MCRL2_LPS_DEADLOCK_H #include "mcrl2/atermpp/aterm_traits.h" #include "mcrl2/data/data_expression.h" #include "mcrl2/data/print.h" #include "mcrl2/data/real.h" namespace mcrl2 { namespace lps { /// \brief Represents a deadlock /// \detail A deadlock is 'delta' with an optional time tag. class deadlock { friend class deadlock_summand; friend struct atermpp::aterm_traits; protected: /// \brief The time of the deadlock. If m_time == data::data_expression() /// the multi action has no time. data::data_expression m_time; /// \brief Protects the term from being freed during garbage collection. void protect() const { m_time.protect(); } /// \brief Unprotect the term. /// Releases protection of the term which has previously been protected through a /// call to protect. void unprotect() const { m_time.unprotect(); } /// \brief Mark the term for not being garbage collected. void mark() const { m_time.mark(); } public: /// \brief Constructor deadlock(data::data_expression time = atermpp::aterm_appl(core::detail::gsMakeNil())) : m_time(time) {} /// \brief Returns true if time is available. /// \return True if time is available. bool has_time() const { return m_time != core::detail::gsMakeNil(); } /// \brief Returns the time. /// \return The time. const data::data_expression& time() const { return m_time; } /// \brief Returns the time. /// \return The time. data::data_expression& time() { return m_time; } /// \brief Returns a string representation of the deadlock std::string to_string() const { return std::string("delta") + (has_time() ? (" @ " + data::pp(m_time)) : ""); } /// \brief Comparison operator bool operator==(const deadlock& other) { return m_time == other.m_time; } /// \brief Comparison operator bool operator!=(const deadlock& other) { return !(*this == other); } }; // template function overloads std::set find_variables(const lps::deadlock& x); std::set find_free_variables(const lps::deadlock& x); } // namespace lps } // namespace mcrl2 /// \cond INTERNAL_DOCS namespace atermpp { template<> struct aterm_traits { static void protect(const mcrl2::lps::deadlock& t) { t.protect(); } static void unprotect(const mcrl2::lps::deadlock& t) { t.unprotect(); } static void mark(const mcrl2::lps::deadlock& t) { t.mark(); } }; } // namespace atermpp /// \endcond #endif // MCRL2_LPS_DEADLOCK_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/linearise.h000664 001751 001751 00000005305 12042421220 024255 0ustar00jenkinsjenkins000000 000000 // Author(s): Jan Friso Groote // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/linearise.h /// \brief Linearisation of process specifications #ifndef MCRL2_LPS_LINEARISE_H #define MCRL2_LPS_LINEARISE_H #include #include "mcrl2/data/rewriter.h" #include "mcrl2/lps/linearisation_method.h" #include "mcrl2/lps/specification.h" #include "mcrl2/process/process_specification.h" #include "mcrl2/process/parse.h" namespace mcrl2 { namespace lps { /// \brief Options for linearisation struct t_lin_options { t_lin_method lin_method; bool no_intermediate_cluster; bool final_cluster; bool newstate; bool binary; bool statenames; bool norewrite; bool noglobalvars; bool nosumelm; bool nodeltaelimination; bool add_delta; bool do_not_apply_constelm; mcrl2::data::basic_rewriter< mcrl2::data::data_expression >::strategy rewrite_strategy; std::string infilename; std::string outfilename; t_lin_options() : lin_method(lmRegular), no_intermediate_cluster(false), final_cluster(false), newstate(false), binary(false), statenames(false), norewrite(false), noglobalvars(false), nosumelm(false), nodeltaelimination(false), add_delta(false), do_not_apply_constelm(false), rewrite_strategy(mcrl2::data::jitty) {} }; /// \brief Linearises a process specification /// \param[in] spec A process specification /// \param[in] lin_options options that should be used during linearisation /// \return An LPS equivalent to spec, which is linearised using lin_options /// \exception mcrl2::runtime_error Linearisation failed mcrl2::lps::specification linearise( const mcrl2::process::process_specification& spec, mcrl2::lps::t_lin_options lin_options = t_lin_options()); /// \brief Linearises a process specification from a textual specification /// \param[in] text A string containing a process specification /// \param[in] lin_options options that should be used during linearisation /// \return An LPS equivalent to the specification representing text, which is linearised using lin_options /// \exception mcrl2::runtime_error Linearisation failed inline mcrl2::lps::specification linearise( const std::string& text, mcrl2::lps::t_lin_options lin_options = t_lin_options()) { mcrl2::process::process_specification spec = mcrl2::process::parse_process_specification(text,true); return linearise(spec, lin_options); } } // namespace lps } // namespace mcrl2 #endif // MCRL2_LPS_LINEARISE_H mcrl2-201210.1/libraries/lps/include/mcrl2/lps/find.h000664 001751 001751 00000015003 12042421220 023216 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/data/find.h /// \brief Search functions of the data library. #ifndef MCRL2_LPS_FIND_H #define MCRL2_LPS_FIND_H #include "mcrl2/utilities/exception.h" #include "mcrl2/core/detail/print_utility.h" #include "mcrl2/data/variable.h" #include "mcrl2/data/find.h" #include "mcrl2/lps/traverser.h" #include "mcrl2/lps/add_binding.h" namespace mcrl2 { namespace lps { //--- start generated lps find code ---// /// \brief Returns all variables that occur in an object /// \param[in] x an object containing variables /// \param[in,out] o an output iterator to which all variables occurring in x are written. /// \return All variables that occur in the term x template void find_variables(const T& x, OutputIterator o) { data::detail::make_find_variables_traverser(o)(x); } /// \brief Returns all variables that occur in an object /// \param[in] x an object containing variables /// \return All variables that occur in the object x template std::set find_variables(const T& x) { std::set result; lps::find_variables(x, std::inserter(result, result.end())); return result; } /// \brief Returns all variables that occur in an object /// \param[in] x an object containing variables /// \param[in,out] o an output iterator to which all variables occurring in x are added. /// \return All free variables that occur in the object x template void find_free_variables(const T& x, OutputIterator o) { data::detail::make_find_free_variables_traverser(o)(x); } /// \brief Returns all variables that occur in an object /// \param[in] x an object containing variables /// \param[in,out] o an output iterator to which all variables occurring in x are written. /// \param[in] bound a container of variables /// \return All free variables that occur in the object x template void find_free_variables_with_bound(const T& x, OutputIterator o, const VariableContainer& bound) { data::detail::make_find_free_variables_traverser(o, bound)(x); } /// \brief Returns all variables that occur in an object /// \param[in] x an object containing variables /// \return All free variables that occur in the object x template std::set find_free_variables(const T& x) { std::set result; lps::find_free_variables(x, std::inserter(result, result.end())); return result; } /// \brief Returns all variables that occur in an object /// \param[in] x an object containing variables /// \param[in] bound a bound a container of variables /// \return All free variables that occur in the object x template std::set find_free_variables_with_bound(const T& x, VariableContainer const& bound) { std::set result; lps::find_free_variables_with_bound(x, std::inserter(result, result.end()), bound); return result; } /// \brief Returns all identifiers that occur in an object /// \param[in] x an object containing identifiers /// \param[in,out] o an output iterator to which all identifiers occurring in x are written. /// \return All identifiers that occur in the term x template void find_identifiers(const T& x, OutputIterator o) { data::detail::make_find_identifiers_traverser(o)(x); } /// \brief Returns all identifiers that occur in an object /// \param[in] x an object containing identifiers /// \return All identifiers that occur in the object x template std::set find_identifiers(const T& x) { std::set result; lps::find_identifiers(x, std::inserter(result, result.end())); return result; } /// \brief Returns all sort expressions that occur in an object /// \param[in] x an object containing sort expressions /// \param[in,out] o an output iterator to which all sort expressions occurring in x are written. /// \return All sort expressions that occur in the term x template void find_sort_expressions(const T& x, OutputIterator o) { data::detail::make_find_sort_expressions_traverser(o)(x); } /// \brief Returns all sort expressions that occur in an object /// \param[in] x an object containing sort expressions /// \return All sort expressions that occur in the object x template std::set find_sort_expressions(const T& x) { std::set result; lps::find_sort_expressions(x, std::inserter(result, result.end())); return result; } /// \brief Returns all function symbols that occur in an object /// \param[in] x an object containing function symbols /// \param[in,out] o an output iterator to which all function symbols occurring in x are written. /// \return All function symbols that occur in the term x template void find_function_symbols(const T& x, OutputIterator o) { data::detail::make_find_function_symbols_traverser(o)(x); } /// \brief Returns all function symbols that occur in an object /// \param[in] x an object containing function symbols /// \return All function symbols that occur in the object x template std::set find_function_symbols(const T& x) { std::set result; lps::find_function_symbols(x, std::inserter(result, result.end())); return result; } //--- end generated lps find code ---// /// \brief Returns true if the term has a given variable as subterm. /// \param[in] container an expression or container with expressions /// \param d A data variable /// \return True if the term has a given variable as subterm. template bool search_free_variable(const Container& container, const data::variable& d) { // TODO: replace this by a more efficient implementation std::set variables = lps::find_free_variables(container); return variables.find(d) != variables.end(); } } // namespace lps } // namespace mcrl2 #endif mcrl2-201210.1/libraries/lps/include/mcrl2/lps/builder.h000664 001751 001751 00000015524 12042421220 023734 0ustar00jenkinsjenkins000000 000000 // Author(s): Wieger Wesselink // Copyright: see the accompanying file COPYING or copy at // https://svn.win.tue.nl/trac/MCRL2/browser/trunk/COPYING // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // /// \file mcrl2/lps/builder.h /// \brief add your file description here. #ifndef MCRL2_LPS_BUILDER_H #define MCRL2_LPS_BUILDER_H #include "mcrl2/core/builder.h" #include "mcrl2/data/builder.h" #include "mcrl2/lps/specification.h" namespace mcrl2 { namespace lps { // Adds sort expression traversal to a builder //--- start generated add_sort_expressions code ---// template