text:
#include "parsectx.h"
#include "parser.h"
#include "lexer.h"

#include <stdarg.h>
#include <stdlib.h>
#include <ctype.h>
#include "yystype.h"
#include "ast.h"
#include <butils/strtk.h>
#include <cutils/dbuf.h>
#include "ld.h"
#include "inc.h"
#include <butils/fn.h>
#include <unistd.h>

#define ERROR_MSG_LEN 4096

/* global used throughout lexer and parser */
//PARSECONTEXT *parse_context;

#ifndef IS_REENTRANT
YYLTYPE yyloc;
#endif

#define YYLLOC_DEFAULT(Current, Rhs, N)                                      \
         do                                                                  \
           if (N)                                                            \
             {								     \
		(Current).file_id	  = YYRHSLOC(Rhs, 1).file_id;	     \
		(Current).first_line   = YYRHSLOC(Rhs, 1).first_line;        \
		(Current).first_column = YYRHSLOC(Rhs, 1).first_column;      \
		(Current).last_line    = YYRHSLOC(Rhs, N).last_line;         \
		(Current).last_column  = YYRHSLOC(Rhs, N).last_column;       \
             }                                                               \
           else                                                              \
             {                                                               \
	       (Current).file_id	  = YYRHSLOC(Rhs, 0).file_id;        \
               (Current).first_line   = (Current).last_line   =              \
                 YYRHSLOC(Rhs, 0).last_line;                                 \
               (Current).first_column = (Current).last_column =              \
                 YYRHSLOC(Rhs, 0).last_column;                               \
             }                                                               \
         while (0)

/* include bison generated code */

#if 0
/* doesn't work with older versions of gcc */
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif

#define YYERROR_VERBOSE

#ifdef TRACE_PARSER
#define YYDEBUG 1
#endif

#include "pars.txt"

/*
  Function name - MY_YY_fancy_error

  Description - write error report line to stderr, where the error token is underlined with ^^^ characters

  Input -    line			input line
			 line_num		line number
			 column_start   column start of error token
			 column_end     column end of error token

  Return Code/Output
 */
static void fancy_error(const char *line, int line_num, int column_start, int column_end, int show_highlight )
{
	int pos;

	fprintf(stderr, " %6d |", line_num );

	for(pos = 0; pos < 80; ++pos ) {
	   if (pos % 10 == 0) {
	     fprintf(stderr,":");
	   } else if (pos % 5 == 0) {
	     fprintf(stderr,"+");
	   } else {
	     fprintf(stderr,".");
	   }
	}
	fprintf(stderr , "\n        |%s\n        |" , line);

	if ( show_highlight )
	{
	for(pos = 0; pos < column_start; pos++) {
		fprintf(stderr,".");
	}

	do {
		fprintf(stderr,"^");
	} while( ++pos <= column_end);

	fprintf(stderr,"\n");
	}
}

/*
  Function name - MY_YY_fancy_error

  Description - write error report line to stderr, where the error token is underlined with ^^^ characters

  Input -    location location of error (columns, lines)
			 file filename of source file that contains the error

  Return Code/Output - 0 - ok, -1 error
 */
static int fancy_error_report(YYLTYPE *location, const char *file, int show_highlight)
{
	int	 line_num = 1;
	int	 ch;
	char	 by;
        DBUF	 buf;

	FILE *fp = fopen(file,"r");
	if (!fp) {
		return -1;
	}

	DBUF_init( &buf, 10 );

	while( (ch = fgetc( fp ) ) != -1 ) {
	   if (ch == '\n') {
	     if (line_num == location->first_line) {
	       break;
	      }
	      ++line_num;
	      continue;
	   }

	   if (ch == '\t') ch = ' ';

	   if (line_num == location->first_line) {
	     by = (char ) ch;
	     DBUF_add( &buf, &by, 1);
	   }
	}
	DBUF_add_null( &buf );

	fancy_error( (char *) buf.buf, location->first_line, location->first_column, location->last_column,  show_highlight  );
	fclose(fp);
	return 0;
}

void SHOW_SOURCE_LINE_impl (YYLTYPE *loc, PARSECONTEXT *parse_context )
{
   YYLTYPE lloc = *loc;
   while( lloc.first_line <= lloc.last_line)
   {
     fancy_error_report( &lloc,
	LEXER_get_file_name( &parse_context->lexctx, lloc.file_id ), 0 );
     lloc.first_line ++;
   }
}

#define S_TOKEN_STRART "TK_"
#define S_TOKEN_START_LEN 3

char *translate_token(const char *msg) {

    char *tok;
    char *news, *ch;
    char *copy;

    news = malloc( strlen( msg ) + 1 );
    if (!news) {
  	return 0;
    }
    strcpy(news,"");

    copy = strdup( msg + S_TOKEN_START_LEN );
    if (!copy) {
	free(news);
	return 0;
    }
    for( tok = strtok( copy, "_"); tok != 0; tok = strtok( 0, "_" ) ) {

	for( ch = tok; *ch != '\0'; ch++) {
	  *ch = tolower( (int) * ch );
	}
	strcat(news, tok);
        strcat(news," ");
    }
    free(copy);
    return news;
}
/*
   The token names start with TK_ by convention; this function turns them into something nice and readable.
 */
char *translate_message(const char *in_msg)
{
    const char *pos, *tok;
    char *news, *npos;
    STRTK stok;
    DBUF dbuf;

    char *msg;

    msg = strdup(in_msg);
    if (msg == 0) {
        return "internal error";
    }

    STRTK_init( &stok, " \t" );
    DBUF_init( &dbuf, 10 );

    for( pos = msg, tok = STRTK_tok_mod( &stok, pos, &npos );
	    tok != 0; pos = npos, tok = STRTK_tok_mod( &stok, pos, &npos ) ) {

       news = 0;
       if (strncmp( tok, S_TOKEN_STRART, S_TOKEN_START_LEN ) == 0) {
          news = translate_token( tok  );
          DBUF_add( &dbuf, news, strlen(news) );
          free(news);
      } else {
        DBUF_add( &dbuf, tok, strlen(tok) );
        DBUF_add( &dbuf, " ", 1 );
      }

      pos = npos;
    }
    DBUF_add_null( &dbuf );
    free(msg);

    return (char *) dbuf.buf;
}

/*
  Function name - do_yyerror

  Description - called by yac/lex as well as syntax analysis/code generation to display an error.

  Input -    loc location of error (columns, lines, file_id)
			 fomat format spec of error message (variable line error message)

  Return Code/Output - none
 */
void do_yyerror (YYLTYPE *loc, PARSECONTEXT *parse_context, const char  *format, ...)
{
  char msg[ERROR_MSG_LEN];
  int len;
  va_list ap;
  YYLTYPE local_loc;

  if (! parse_context->report_errors ) {
    return;
  }

  if (!loc) {
    local_loc = LEXER_get_location( & parse_context->lexctx );
    loc = &local_loc;
  }

  va_start(ap, format);
  len =
#ifdef WIN32
	_vsnprintf
#else
	vsnprintf
#endif

	(msg, sizeof(msg) - 1, format, ap);
  va_end(ap);

  msg[len] = '\0';

  parse_context->my_yy_is_error = 1;
  fprintf (stderr, "\n%s(%d): Error: %s\n",
	LEXER_get_file_name( &parse_context->lexctx , loc->file_id ),
	loc->first_line,
	msg);

  fancy_error_report( loc,
	LEXER_get_file_name( &parse_context->lexctx, loc->file_id), 1 );
}

void do_yywarning (YYLTYPE *loc, PARSECONTEXT *parse_context, const char  *format, ...)
{
  char msg[ERROR_MSG_LEN];
  int len;
  va_list ap;

  if (! parse_context->report_errors ) {
    return;
  }

  va_start(ap, format);
  len =
#ifdef WIN32
	_vsnprintf
#else
	vsnprintf
#endif

	(msg, sizeof(msg) - 1, format, ap);
  va_end(ap);

  msg[len] = '\0';

  parse_context->my_yy_is_error = 1;
  fprintf (stderr, "\n%s(%d): Warning: %s\n",
	LEXER_get_file_name( &parse_context->lexctx , loc->file_id ),
	loc->first_line,
	msg);

  fancy_error_report( loc,
	LEXER_get_file_name( &parse_context->lexctx, loc->file_id), 1 );
}

/*
  Function name - yyerror

  Description - called by yac/lex as to display an error.

  Input -    msg - error message text

  Return Code/Output - none
 */
void yyerror (YYLTYPE *loc, PARSECONTEXT *parse_context, char const *msg)
{
  char *nmsg;

  nmsg = translate_message( msg );
  do_yyerror( loc, parse_context, "%s", nmsg );
  free( nmsg );
}

/*
  Function name - MY_YY_parse

  Description - parse a source file with flex/bison.
				during this process the AST - abstract syntax treee - is built.

  Input -

  Return Code/Output -  0 - ok, != 0 failure.
						root base node of abstract syntax tree.

 */

int PARSER_run(PARSECONTEXT *ctx, struct tagAST_BASE **rval  )
{
	int ret = 0;

#ifdef TRACE_PARSER
	yydebug = 1;
#endif

	ret = yyparse( ctx );
	if (ret) {

#ifdef TRACE_PARSER
	  fprintf( stderr, "---yyparer failed; returns %d\n", ret );
#endif
	  return ret;
	}

#ifdef TRACE_PARSER
	fprintf( stderr, "---yyparse ok\n" );
#endif

	*rval = ctx->my_ast_root;
	return ctx->my_yy_is_error;
}

PARSECONTEXT * PARSER_init( INC_PATH *inc_path )
{
  PARSECONTEXT *ret;

  ret = (PARSECONTEXT *) malloc( sizeof( PARSECONTEXT ) );
  if (!ret) {
    return 0;
  }

  memset( ret, 0, sizeof( PARSECONTEXT ) );

  if (PARSECONTEXT_init( ret, inc_path )) {
    return 0;
  }

  return ret;

}

int PARSER_free(PARSECONTEXT *ctx)
{
  SHLIB **val;
  size_t i;

  if (LEXER_free( &ctx->lexctx )) {
    return -1;
  }

  // unload extension libraries
  for( i = 0; i < ARRAY_size( &ctx->extension_libs ); i ++ ) {
    val = (SHLIB ** ) ARRAY_at( &ctx->extension_libs, i );
    SHLIB_unload( *val );
    free( *val );
  }

  return 0;
}

typedef  AST_XFUNC_DECL * (*FN_get_honey_jar_interface) ();

#if defined(__CYGWIN__) || defined(_WIN32)
#define SHARED_LIBRARY_EXTENSION ".dll"
#else
#define SHARED_LIBRARY_EXTENSION ".so"
#endif

int load_extension_library(PARSECONTEXT * ctx,  YYLTYPE *loc, const char *sval )
{
  char *alt_name = 0;
  SHLIB *shlib = 0;
  FN_get_honey_jar_interface get_iface;
  size_t i;
  AST_XFUNC_DECL *xlib;

  if (access( sval, R_OK )) {
     alt_name = INC_PATH_resolve( ctx->lexctx.inc_path, sval );
     if (!alt_name) {
       char *spath;
       char *sval2 =  FN_set_extension( sval, SHARED_LIBRARY_EXTENSION );
       if (sval2) {
         alt_name = INC_PATH_resolve( ctx->lexctx.inc_path, sval2 );
       }
       free(sval2);

       if (!alt_name) {
          spath = INC_PATH_to_text( ctx->lexctx.inc_path );

	  do_yyerror( loc, ctx,  "Can't open file %s, tried to open the file in current directory %s%s Try to specify the search path with -I <directory name> or -i <directory name> command line options.",
		sval,
		spath != 0 ? "and then in each directory that is part of the search path: " : 0,
		spath != 0 ? spath : 0 );
          goto err;
      }
     }
     sval = alt_name;
  }

  shlib = (SHLIB *) malloc( sizeof( SHLIB ) );
  if  (!shlib || SHLIB_load( shlib, sval )) {
    do_yyerror( loc, ctx, "can't load the extension library %s. %s",  sval, shlib->last_error ? shlib->last_error : 0);
    goto err;
  }

  get_iface = (FN_get_honey_jar_interface) SHLIB_get_proc_addr( shlib, "get_honey_jar_interface" );
  if (!get_iface) {
    do_yyerror( loc, ctx, "can't load the extension library %s. It does not have a function called get_honey_jar_interface.  %s", sval, shlib->last_error ? shlib->last_error : 0);
    goto err;
  }

  xlib = get_iface();
  if (!xlib) {
    do_yyerror( loc, ctx, "can't load the extension library %s. the get_honey_jar_interface did not return a value", sval );
    goto err;
  }

  for(i=0; xlib[i].f_name != 0 ; i++ )
  {
    PARSECONTEXT_add_function_def(  ctx, &xlib[i] );
  }

  ARRAY_push_back( &ctx->extension_libs, &shlib, sizeof(void *) );
  return 0;

err:
  if (shlib) {
    SHLIB_unload(shlib);
    free(shlib);
  }
  if (alt_name)
    free(alt_name);
  return 1;
}


text:
package org.apache.asterix.runtime.evaluators.constructors;

import java.io.DataOutput;
import java.io.IOException;

import org.apache.asterix.dataflow.data.nontagged.serde.APointSerializerDeserializer;
import org.apache.asterix.formats.nontagged.AqlSerializerDeserializerProvider;
import org.apache.asterix.om.base.ANull;
import org.apache.asterix.om.functions.AsterixBuiltinFunctions;
import org.apache.asterix.om.functions.IFunctionDescriptor;
import org.apache.asterix.om.functions.IFunctionDescriptorFactory;
import org.apache.asterix.om.types.ATypeTag;
import org.apache.asterix.om.types.BuiltinType;
import org.apache.asterix.runtime.evaluators.base.AbstractScalarFunctionDynamicDescriptor;
import org.apache.hyracks.algebricks.common.exceptions.AlgebricksException;
import org.apache.hyracks.algebricks.core.algebra.functions.FunctionIdentifier;
import org.apache.hyracks.algebricks.runtime.base.IScalarEvaluator;
import org.apache.hyracks.algebricks.runtime.base.IScalarEvaluatorFactory;
import org.apache.hyracks.api.context.IHyracksTaskContext;
import org.apache.hyracks.api.dataflow.value.ISerializerDeserializer;
import org.apache.hyracks.data.std.api.IPointable;
import org.apache.hyracks.data.std.primitive.UTF8StringPointable;
import org.apache.hyracks.data.std.primitive.VoidPointable;
import org.apache.hyracks.data.std.util.ArrayBackedValueStorage;
import org.apache.hyracks.dataflow.common.data.accessors.IFrameTupleReference;

public class APolygonConstructorDescriptor extends AbstractScalarFunctionDynamicDescriptor {
    private static final long serialVersionUID = 1L;
    public static final IFunctionDescriptorFactory FACTORY = new IFunctionDescriptorFactory() {
        @Override
        public IFunctionDescriptor createFunctionDescriptor() {
            return new APolygonConstructorDescriptor();
        }
    };

    @Override
    public IScalarEvaluatorFactory createEvaluatorFactory(final IScalarEvaluatorFactory[] args) {
        return new IScalarEvaluatorFactory() {
            private static final long serialVersionUID = 1L;

            @Override
            public IScalarEvaluator createScalarEvaluator(IHyracksTaskContext ctx) throws AlgebricksException {
                return new IScalarEvaluator() {

                    private ArrayBackedValueStorage resultStorage = new ArrayBackedValueStorage();
                    private DataOutput out = resultStorage.getDataOutput();
                    private IPointable inputArg = new VoidPointable();
                    private IScalarEvaluator eval = args[0].createScalarEvaluator(ctx);
                    private String errorMessage = "This can not be an instance of polygon";
                    @SuppressWarnings("unchecked")
                    private ISerializerDeserializer<ANull> nullSerde = AqlSerializerDeserializerProvider.INSTANCE
                            .getSerializerDeserializer(BuiltinType.ANULL);
                    private final UTF8StringPointable utf8Ptr = new UTF8StringPointable();

                    @Override
                    public void evaluate(IFrameTupleReference tuple, IPointable result) throws AlgebricksException {

                        try {
                            resultStorage.reset();
                            eval.evaluate(tuple, inputArg);
                            byte[] serString = inputArg.getByteArray();
                            int offset = inputArg.getStartOffset();
                            int len = inputArg.getLength();

                            if (serString[offset] == ATypeTag.SERIALIZED_STRING_TYPE_TAG) {
                                utf8Ptr.set(serString, offset + 1, len - 1);
                                String s = utf8Ptr.toString();
                                String[] points = s.split(" ");
                                if (points.length <= 2) {
                                    throw new AlgebricksException(errorMessage);
                                }
                                out.writeByte(ATypeTag.SERIALIZED_POLYGON_TYPE_TAG);
                                out.writeShort(points.length);
                                for (int i = 0; i < points.length; i++) {
                                    APointSerializerDeserializer.serialize(Double.parseDouble(points[i].split(",")[0]),
                                            Double.parseDouble(points[i].split(",")[1]), out);
                                }
                            } else if (serString[offset] == ATypeTag.SERIALIZED_NULL_TYPE_TAG) {
                                nullSerde.serialize(ANull.NULL, out);
                            } else {
                                throw new AlgebricksException(errorMessage);
                            }
                            result.set(resultStorage);
                        } catch (IOException e1) {
                            throw new AlgebricksException(errorMessage);
                        }
                    }
                };
            }
        };
    }

    @Override
    public FunctionIdentifier getIdentifier() {
        return AsterixBuiltinFunctions.POLYGON_CONSTRUCTOR;
    }

}

redpajama_set_name: RedPajamaGithub


text:
@class DBFILESDimensions;

NS_ASSUME_NONNULL_BEGIN

#pragma mark - API Object

///
/// The `Dimensions` struct.
///
/// Dimensions for a photo or video.
///
/// This class implements the `DBSerializable` protocol (serialize and
/// deserialize instance methods), which is required for all Obj-C SDK API route
/// objects.
///
@interface DBFILESDimensions : NSObject <DBSerializable, NSCopying>

#pragma mark - Instance fields

/// Height of the photo/video.
@property (nonatomic, readonly) NSNumber *height;

/// Width of the photo/video.
@property (nonatomic, readonly) NSNumber *width;

#pragma mark - Constructors

///
/// Full constructor for the struct (exposes all instance variables).
///
/// @param height Height of the photo/video.
/// @param width Width of the photo/video.
///
/// @return An initialized instance.
///
- (instancetype)initWithHeight:(NSNumber *)height width:(NSNumber *)width;

- (instancetype)init NS_UNAVAILABLE;

@end

#pragma mark - Serializer Object

///
/// The serialization class for the `Dimensions` struct.
///
@interface DBFILESDimensionsSerializer : NSObject

///
/// Serializes `DBFILESDimensions` instances.
///
/// @param instance An instance of the `DBFILESDimensions` API object.
///
/// @return A json-compatible dictionary representation of the
/// `DBFILESDimensions` API object.
///
+ (nullable NSDictionary *)serialize:(DBFILESDimensions *)instance;

///
/// Deserializes `DBFILESDimensions` instances.
///
/// @param dict A json-compatible dictionary representation of the
/// `DBFILESDimensions` API object.
///
/// @return An instantiation of the `DBFILESDimensions` object.
///
+ (DBFILESDimensions *)deserialize:(NSDictionary *)dict;

@end

NS_ASSUME_NONNULL_END


text:
'use strict';

/**
 * Module dependencies.
 */
var mongoose = require('mongoose'),
	Schema = mongoose.Schema;

/**
 * Attendence Schema
 */
var AttendenceSchema = new Schema({
	name: {
		type: String,
		default: '',
		required: 'Please fill Attendence name',
		trim: true
	},
	created: {
		type: Date,
		default: Date.now
	},
	user: {
		type: Schema.ObjectId,
		ref: 'User'
	}
});

mongoose.model('Attendence', AttendenceSchema);


text:
typedef signed char int8;
typedef unsigned char uint8;

typedef signed short int16;
typedef unsigned short uint16;

typedef signed int int32;
typedef unsigned int uint32;

typedef signed long long int64;
typedef unsigned long long uint64;

typedef char* string;

//define boolean type and boolean literals
typedef char bool;

#define true (1 == 1)
#define false (1 == 0)

#endif


text:
Cuba
====

_n_. a microframework for web development.

![Cuba and Rum, by Jan Sochor](http://farm3.static.flickr.com/2619/4032103097_8324c6fecf.jpg)

Community
---------

Meet us on IRC: [#cuba.rb][irc] on [freenode.net][freenode].

[irc]: irc://chat.freenode.net/#cuba.rb
[freenode]: http://freenode.net/

Description
-----------

Cuba is a microframework for web development originally inspired
by [Rum][rum], a tiny but powerful mapper for [Rack][rack]
applications.

It integrates many templates via [Tilt][tilt], and testing via
[Cutest][cutest] and [Capybara][capybara].

[rum]: http://github.com/chneukirchen/rum
[rack]: http://github.com/rack/rack
[tilt]: http://github.com/rtomayko/tilt
[cutest]: http://github.com/djanowski/cutest
[capybara]: http://github.com/jnicklas/capybara
[rack-test]: https://github.com/brynary/rack-test

Installation
------------

``` console
$ gem install cuba
```

Usage
-----

Here's a simple application:

``` ruby
# cat hello_world.rb
require "cuba"
require "cuba/safe"

Cuba.use Rack::Session::Cookie, :secret => "__a_very_long_string__"

Cuba.plugin Cuba::Safe

Cuba.define do
  on get do
    on "hello" do
      res.write "Hello world!"
    end

    on root do
      res.redirect "/hello"
    end
  end
end
```

And the test file:

``` ruby
# cat hello_world_test.rb
require "cuba/test"
require "./hello_world"

scope do
  test "Homepage" do
    get "/"

    follow_redirect!

    assert_equal "Hello world!", last_response.body
  end
end
```

To run it, you can create a `config.ru` file:

``` ruby
# cat config.ru
require "./hello_world"

run Cuba
```

You can now run `rackup` and enjoy what you have just created.

Matchers
--------

Here's an example showcasing how different matchers work:

``` ruby
require "cuba"
require "cuba/safe"

Cuba.use Rack::Session::Cookie, :secret => "__a_very_long_string__"

Cuba.plugin Cuba::Safe

Cuba.define do

  # only GET requests
  on get do

    # /
    on root do
      res.write "Home"
    end

    # /about
    on "about" do
      res.write "About"
    end

    # /styles/basic.css
    on "styles", extension("css") do |file|
      res.write "Filename: #{file}" #=> "Filename: basic"
    end

    # /post/2011/02/16/hello
    on "post/:y/:m/:d/:slug" do |y, m, d, slug|
      res.write "#{y}-#{m}-#{d} #{slug}" #=> "2011-02-16 hello"
    end

    # /username/foobar
    on "username/:username" do |username|
      user = User.find_by_username(username) # username == "foobar"

      # /username/foobar/posts
      on "posts" do

        # You can access `user` here, because the `on` blocks
        # are closures.
        res.write "Total Posts: #{user.posts.size}" #=> "Total Posts: 6"
      end

      # /username/foobar/following
      on "following" do
        res.write user.following.size #=> "1301"
      end
    end

    # /search?q=barbaz
    on "search", param("q") do |query|
      res.write "Searched for #{query}" #=> "Searched for barbaz"
    end
  end

  # only POST requests
  on post do
    on "login" do

      # POST /login, user: foo, pass: baz
      on param("user"), param("pass") do |user, pass|
        res.write "#{user}:#{pass}" #=> "foo:baz"
      end

      # If the params `user` and `pass` are not provided, this
      # block will get executed.
      on true do
        res.write "You need to provide user and pass!"
      end
    end
  end
end
```

Note that once an `on` block matches, processing halts at the conclusion of that block.

Status codes
------------

If you don't assign a status code and you don't write to the `res`
object, the status will be set as `404`. The method `not_found` is
in charge of setting the proper status code, and you can redefine
it if you want to render a template or configure custom headers.

For example:

``` ruby
Cuba.define do
  on get do
    on "hello" do
      res.write "hello world"
    end
  end
end

# Requests:
#
# GET /            # 404
# GET /hello       # 200
# GET /hello/world # 200
```

As you can see, as soon as something was written to the response,
the status code was changed to 200.

If you want to match just "hello", but not "hello/world", you can do
as follows:

``` ruby
Cuba.define do
  on get do
    on "hello" do
      on root do
        res.write "hello world"
      end
    end
  end
end

# Requests:
#
# GET /            # 404
# GET /hello       # 200
# GET /hello/world # 404
```

You can also use a regular expression to match the end of line:

``` ruby
Cuba.define do
  on get do
    on /hello\/?\z/ do
      res.write "hello world"
    end
  end
end

# Requests:
#
# GET /            # 404
# GET /hello       # 200
# GET /hello/world # 404
```

This last example is not a common usage pattern. It's here only to
illustrate how Cuba can be adapted for different use cases.

If you need this behavior, you can create a helper:

``` ruby
module TerminalMatcher
  def terminal(path)
    /#{path}\/?\z/
  end
end

Cuba.plugin TerminalMatcher

Cuba.define do
  on get do
    on terminal("hello") do
      res.write "hello world"
    end
  end
end
```

Security
--------

The most important security consideration is to use `https` for all
requests. If that's not the case, any attempt to secure the application
could be in vain. The rest of this section assumes `https` is
enforced.

When building a web application, you need to include a security
layer. Cuba ships with the `Cuba::Safe` plugin, which applies several
security related headers to prevent attacks like clickjacking and
cross-site scripting, among others. It is not included by default
because there are legitimate uses for plain Cuba (for instance,
when designing an API).

Here's how to include it:

```ruby
require "cuba/safe"

Cuba.plugin Cuba::Safe
```

You should also always set a session secret to some undisclosed
value. Keep in mind that the content in the session cookie is
*not* encrypted.

``` ruby
Cuba.use(Rack::Session::Cookie, :secret => "__a_very_long_string__")
```

In the end, your application should look like this:

```ruby
require "cuba"
require "cuba/safe"

Cuba.use Rack::Session::Cookie, :secret => "__a_very_long_string__"

Cuba.plugin Cuba::Safe

Cuba.define do
  on csrf.unsafe? do
    csrf.reset!

    res.status = 403
    res.write("Not authorized")

    halt(res.finish)
  end

  # Now your app is protected against a wide range of attacks.
  ...
end
```

The `Cuba::Safe` plugin is composed of two modules:

* `Cuba::Safe::SecureHeaders`
* `Cuba::Safe::CSRF`

You can include them individually, but while the modularity is good
for development, it's very common to use them in tandem. As that's
the normal use case, including `Cuba::Safe` is the preferred way.

Cross-Site Request Forgery
--------------------------

The `Cuba::Safe::CSRF` plugin provides a `csrf` object with the
following methods:

* `token`: the current security token.
* `reset!`: forces the token to be recreated.
* `safe?`: returns `true` if the request is safe.
* `unsafe?`: returns `true` if the request is unsafe.
* `form_tag`: returns a string with the `csrf_token` hidden input tag.
* `meta_tag`: returns a string with the `csrf_token` meta tag.

Here's an example of how to use it:

```ruby
require "cuba"
require "cuba/safe"

Cuba.use Rack::Session::Cookie, :secret => "__a_very_long_string__"

Cuba.plugin Cuba::Safe

Cuba.define do
  on csrf.unsafe? do
    csrf.reset!

    res.status = 403
    res.write("Forbidden")

    halt(res.finish)
  end

  # Here comes the rest of your application
  # ...
end
```

You have to include `csrf.form_tag` in your forms and `csrf.meta_tag`
among your meta tags. Here's an example that assumes you are using
`Cuba::Mote` from `cuba-contrib`:

```html
<!DOCTYPE html>
<html>
  <head>
    {{ app.csrf.meta_tag }}
    ...
  </head>
  ...
  <body>
    <form action="/foo" method="POST">
      {{ app.csrf.form_tag }}
      ...
    </form>
  ...
  </body>
</html>
```

HTTP Verbs
----------

There are matchers defined for the following HTTP Verbs: `get`,
`post`, `put`, `patch`, `delete`, `head`, `options`, `link`, `unlink`
and `trace`. As you have the whole request available via the `req`
object, you can also query it with helper methods like `req.options?`
or `req.head?`, or you can even go to a lower level and inspect the
environment via the `env` object, and check for example if
`env["REQUEST_METHOD"]` equals the verb `PATCH`.

What follows is an example of different ways of saying the same thing:

``` ruby
on env["REQUEST_METHOD"] == "GET", "api" do ... end

on req.get?, "api" do ... end

on get, "api" do ... end
```

Actually, `get` is syntax sugar for `req.get?`, which in turn is syntax sugar
for `env["REQUEST_METHOD"] == "GET"`.

Headers
-------

You can set the headers by assigning values to the hash `req.headers`.
If you want to inspect the incoming headers, you have to read from
the `env` hash. For example, if you want to know the referrer you
can check `env["HTTP_REFERER"]`.

Request and Response
--------------------

You may have noticed we use `req` and `res` a lot. Those variables are
instances of [Rack::Request][request] and `Cuba::Response` respectively, and
`Cuba::Response` is just an optimized version of
[Rack::Response][response].

[request]: http://www.rubydoc.info/github/rack/rack/Rack/Request
[response]: http://www.rubydoc.info/github/rack/rack/Rack/Response

Those objects are helpers for accessing the request and for building
the response. Most of the time, you will just use `res.write`.

If you want to use custom `Request` or `Response` objects, you can
set the new values as follows:

``` ruby
Cuba.settings[:req] = MyRequest
Cuba.settings[:res] = MyResponse
```

Make sure to provide classes compatible with those from Rack.

Captures
--------

You may have noticed that some matchers yield a value to the block. The rules
for determining if a matcher will yield a value are simple:

1. Regex captures: `"posts/(\\d+)-(.*)"` will yield two values, corresponding to each capture.
2. Placeholders: `"users/:id"` will yield the value in the position of :id.
3. Symbols: `:foobar` will yield if a segment is available.
4. File extensions: `extension("css")` will yield the basename of the matched file.
5. Parameters: `param("user")` will yield the value of the parameter user, if present.

The first case is important because it shows the underlying effect of regex
captures.

In the second case, the substring `:id` gets replaced by `([^\\/]+)` and the
string becomes `"users/([^\\/]+)"` before performing the match, thus it reverts
to the first form we saw.

In the third case, the symbol--no matter what it says--gets replaced
by `"([^\\/]+)"`, and again we are in presence of case 1.

The fourth case, again, reverts to the basic matcher: it generates the string
`"([^\\/]+?)\.#{ext}\\z"` before performing the match.

The fifth case is different: it checks if the the parameter supplied is present
in the request (via POST or QUERY_STRING) and it pushes the value as a capture.

Composition
-----------

You can mount a Cuba app, along with middlewares, inside another Cuba app:

``` ruby
class API < Cuba; end

API.use SomeMiddleware

API.define do
  on param("url") do |url|
    ...
  end
end

Cuba.define do
  on "api" do
    run API
  end
end
```

If you need to pass information to one sub-app, you can use the
`with` method and access it with `vars`:

```ruby
class Platforms < Cuba
  define do
    platform = vars[:platform]

    on default do
      res.write(platform) # => "heroku" or "salesforce"
    end
  end
end

Cuba.define do
  on "(heroku|salesforce)" do |platform|
    with(platform: platform) do
      run(Platforms)
    end
  end
end
```

## Embedding routes from other modules

While the `run` command allows you to handle over the control to a
sub app, sometimes you may want to just embed routes defined in
another module. There's no built-in method to do it, but if you are
willing to experiment you can try the following.

Let's say you have defined routes in modules `A` and `B`, and you
want to mount those routes in your application.

First, you will have to extend Cuba with this code:

```ruby
class Cuba
  def mount(app)
    result = app.call(req.env)
    halt result if result[0] != 404
  end
end
```

It doesn't matter where you define it as long as Cuba has already
been required. For instance, you could extract that to a plugin and
it would work just fine.

Then, in your application, you can use it like this:

```ruby
Cuba.define do
  on default do
    mount A
    mount B
  end
end
```

It should halt the request only if the resulting status from calling
the mounted app is not 404. If you run into some unexpected behavior,
let me know by creating an issue and we'll look at how to workaround
any difficulties.

Testing
-------

Given that Cuba is essentially Rack, it is very easy to test with
`Rack::Test`, `Webrat` or `Capybara`. Cuba's own tests are written
with a combination of [Cutest][cutest] and [Rack::Test][rack-test],
and if you want to use the same for your tests it is as easy as
requiring `cuba/test`:

``` ruby
require "cuba/test"
require "your/app"

scope do
  test "Homepage" do
    get "/"

    assert_equal "Hello world!", last_response.body
  end
end
```

If you prefer to use [Capybara][capybara], instead of requiring
`cuba/test` you can require `cuba/capybara`:

``` ruby
require "cuba/capybara"
require "your/app"

scope do
  test "Homepage" do
    visit "/"

    assert has_content?("Hello world!")
  end
end
```

To read more about testing, check the documentation for
[Cutest][cutest], [Rack::Test][rack-test] and [Capybara][capybara].

Settings
--------

Each Cuba app can store settings in the `Cuba.settings` hash. The settings are
inherited if you happen to subclass `Cuba`

``` ruby
Cuba.settings[:layout] = "guest"

class Users < Cuba; end
class Admin < Cuba; end

Admin.settings[:layout] = "admin"

assert_equal "guest", Users.settings[:layout]
assert_equal "admin", Admin.settings[:layout]
```

Feel free to store whatever you find convenient.

Rendering
---------

Cuba includes a plugin called `Cuba::Render` that provides a couple of helper
methods for rendering templates. This plugin uses [Tilt][tilt], which serves as
an interface to a bunch of different Ruby template engines (ERB, Haml, Sass,
CoffeeScript, etc.), so you can use the template engine of your choice.

To set up `Cuba::Render`, do:

```ruby
require "cuba"
require "cuba/render"
require "erb"

Cuba.plugin Cuba::Render
```

This example uses ERB, a template engine that comes with Ruby. If you want to
use another template engine, one [supported by Tilt][templates], you need to
install the required gem and change the `template_engine` setting as shown
below.

```ruby
Cuba.settings[:render][:template_engine] = "haml"
```

The plugin provides three helper methods for rendering templates: `partial`,
`view` and `render`.

```ruby
Cuba.define do
  on "about" do
    # `partial` renders a template called `about.erb` without a layout.
    res.write partial("about")
  end

  on "home" do
    # Opposed to `partial`, `view` renders the same template
    # within a layout called `layout.erb`.
    res.write view("about")
  end

  on "contact" do
    # `render` is a shortcut to `res.write view(...)`
    render("contact")
  end
end
```

By default, `Cuba::Render` assumes that all templates are placed in a folder
named `views` and that they use the proper extension for the chosen template
engine. Also for the `view` and `render` methods, it assumes that the layout
template is called `layout`.

The defaults can be changed through the `Cuba.settings` method:

```ruby
Cuba.settings[:render][:template_engine] = "haml"
Cuba.settings[:render][:views] = "./views/admin/"
Cuba.settings[:render][:layout] = "admin"
```

NOTE: Cuba doesn't ship with Tilt. You need to install it (`gem install tilt`).

[templates]: https://github.com/rtomayko/tilt/blob/master/docs/TEMPLATES.md

Plugins
-------

Cuba provides a way to extend its functionality with plugins.

### How to create plugins

Authoring your own plugins is pretty straightforward.

``` ruby
module MyOwnHelper
  def markdown(str)
    BlueCloth.new(str).to_html
  end
end

Cuba.plugin MyOwnHelper
```

That's the simplest kind of plugin you'll write. In fact, that's exactly how
the `markdown` helper is written in `Cuba::TextHelpers`.

A more complicated plugin can make use of `Cuba.settings` to provide default
values. In the following example, note that if the module has a `setup` method, it will
be called as soon as it is included:

``` ruby
module Render
  def self.setup(app)
    app.settings[:template_engine] = "erb"
  end

  def partial(template, locals = {})
    render("#{template}.#{settings[:template_engine]}", locals)
  end
end

Cuba.plugin Render
```

This sample plugin actually resembles how `Cuba::Render` works.

Finally, if a module called `ClassMethods` is present, `Cuba` will be extended
with it.

``` ruby
module GetSetter
  module ClassMethods
    def set(key, value)
      settings[key] = value
    end

    def get(key)
      settings[key]
    end
  end
end

Cuba.plugin GetSetter

Cuba.set(:foo, "bar")

assert_equal "bar", Cuba.get(:foo)
assert_equal "bar", Cuba.settings[:foo]
```

Contributing
------------

A good first step is to meet us on IRC and discuss ideas. If that's
not possible, you can create an issue explaining the proposed change
and a use case. We pay a lot of attention to use cases, because our
goal is to keep the code base simple. In many cases, the result of
a conversation will be the creation of another tool, instead of the
modification of Cuba itself.

If you want to test Cuba, you may want to use a gemset to isolate
the requirements. We recommend the use of tools like [dep][dep] and
[gs][gs], but you can use similar tools like [gst][gst] or [bs][bs].

The required gems for testing and development are listed in the
`.gems` file. If you are using [dep][dep], you can create a gemset
and run `dep install`.

[dep]: http://cyx.github.io/dep/
[gs]: http://soveran.github.io/gs/
[gst]: https://github.com/tonchis/gst
[bs]: https://github.com/educabilia/bs


text:
AdminInvitable::Engine.routes.draw do
end


text:
<?php

/* SonataAdminBundle:CRUD:list.html.twig */
class __TwigTemplate_494c7c7e452f0a6a8bda02e55f80a20d1acf4d9c238db017c2dfbdb02adf5eb1 extends Twig_Template
{
    public function __construct(Twig_Environment $env)
    {
        parent::__construct($env);

        $this->parent = $this->env->loadTemplate("SonataAdminBundle:CRUD:base_list.html.twig");

        $this->blocks = array(
        );
    }

    protected function doGetParent(array $context)
    {
        return "SonataAdminBundle:CRUD:base_list.html.twig";
    }

    protected function doDisplay(array $context, array $blocks = array())
    {
        $this->parent->display($context, array_merge($this->blocks, $blocks));
    }

    public function getTemplateName()
    {
        return "SonataAdminBundle:CRUD:list.html.twig";
    }

    public function isTraitable()
    {
        return false;
    }

    public function getDebugInfo()
    {
        return array ();
    }
}


text:
'use strict';
var qs = require('querystring');

/**
 * Tracking providers.
 *
 * Each provider is a function(id, path) that should return
 * options object for request() call. It will be called bound
 * to Insight instance object.
 */

module.exports = {
	// Google Analytics — https://www.google.com/analytics/
	google: function (id, path) {
		var now = Date.now();

		var _qs = {
			v: 1, // GA Measurement Protocol API version
			t: 'pageview', // hit type
			aip: 1, // anonymize IP
			tid: this.trackingCode,
			cid: this.clientId, // random UUID
			cd1: this.os,
			// GA custom dimension 2 = Node Version, scope = Session
			cd2: this.nodeVersion,
			// GA custom dimension 3 = App Version, scope = Session (temp solution until refactored to work w/ GA app tracking)
			cd3: this.appVersion,
			dp: path,
			qt: now - parseInt(id, 10), // queue time - delta (ms) between now and track time
			z: now // cache busting, need to be last param sent
		};

		return {
			url: 'https://ssl.google-analytics.com/collect',
			method: 'POST',
			// GA docs recommends body payload via POST instead of querystring via GET
			body: qs.stringify(_qs)
		};
	},
	// Yandex.Metrica — http://metrica.yandex.com
	yandex: function (id, path) {
		var request = require('request');

		var ts = new Date(parseInt(id, 10))
			.toISOString()
			.replace(/[-:T]/g, '')
			.replace(/\..*$/, '');

		var qs = {
			wmode: 3,
			ut: 'noindex',
			'page-url': 'http://' + this.packageName + '.insight' + path + '?version=' + this.packageVersion,
			'browser-info': 'i:' + ts + ':z:0:t:' + path,
			rn: Date.now() // cache busting
		};

		var url = 'https://mc.yandex.ru/watch/' + this.trackingCode;

		// set custom cookie using tough-cookie
		var _jar = request.jar();
		var cookieString = 'name=yandexuid; value=' + this.clientId + '; path=/;';
		var cookie = request.cookie(cookieString);
		_jar.setCookie(cookie, url);

		return {
			url: url,
			method: 'GET',
			qs: qs,
			jar: _jar
		};
	}
};


text:
foam.CLASS({
  package: 'foam.nanos.test',
  name: 'Test',
  extends: 'foam.nanos.script.Script',

  imports: [ 'testDAO as scriptDAO' ],

  javaImports: [
    'bsh.EvalError',
    'bsh.Interpreter',
    'foam.nanos.pm.PM',
    'java.io.ByteArrayOutputStream',
    'java.io.PrintStream',
    'java.util.Date'
  ],

  tableColumns: [
    'id', 'enabled', 'description', 'passed', 'failed', 'lastRun', 'run'
  ],

  searchColumns: [ ],

  properties: [
    'id',
    {
      class: 'Long',
      name: 'passed',
      visibility: foam.u2.Visibility.RO,
      tableCellFormatter: function(value) {
        if ( value ) this.start().style({color: '#0f0'}).add(value).end();
      }
    },
    {
      class: 'Long',
      name: 'failed',
      visibility: foam.u2.Visibility.RO,
      tableCellFormatter: function(value) {
        if ( value ) this.start().style({color: '#f00'}).add(value).end();
      }
    }
  ],

  methods: [
    {
      /** Template method used to add additional code in subclasses. */
      name: 'runTest',
      javaReturns: 'void',
      javaCode: '/* NOOP */'
    },
    {
      name: 'test',
      args: [
        {
          name: 'exp', javaType: 'boolean'
        },
        {
          name: 'message', javaType: 'String'
        }
      ],
      javaReturns: 'void',
      javaCode: `
        if ( exp ) {
          setPassed(getPassed()+1);
        } else {
          setFailed(getFailed()+1);
        }
        print((exp ? "SUCCESS: " : "FAILURE: ") + message);
      `
    },
    {
      name: 'print',
      args: [
        {
          name: 'message', javaType: 'String'
        }
      ],
      javaReturns: 'void',
      javaCode: `
        setOutput(getOutput() + "\\n" + message);
      `
    },
    {
      name: 'runScript',
      args: [
        {
          name: 'x', javaType: 'foam.core.X'
        }
      ],
      javaReturns: 'void',
      javaCode: `
        ByteArrayOutputStream baos  = new ByteArrayOutputStream();
        PrintStream           ps    = new PrintStream(baos);
        Interpreter           shell = new Interpreter();
        PM                    pm    = new PM(this.getClass(), getId());

        try {
          shell.set("currentTest", this);
          setPassed(0);
          setFailed(0);
          setOutput("");
          shell.set("x", getX());
          shell.setOut(ps);

          // creates the testing method
          shell.eval("test(boolean exp, String message) { if ( exp ) { currentTest.setPassed(currentTest.getPassed()+1); } else { currentTest.setFailed(currentTest.getFailed()+1); } print((exp ? \\"SUCCESS: \\" : \\"FAILURE: \\")+message);}");
          shell.eval(getCode());
          runTest();
        } catch (EvalError e) {
          e.printStackTrace();
        } finally {
          pm.log(x);
        }

        setLastRun(new Date());
        ps.flush();
        System.err.println("******************** Output: " + this.getPassed() + " " + this.getFailed() + " " + baos.toString());
        setOutput(baos.toString() + getOutput());
    `
    }
  ]
});


text:
<?php
class NHP_Options_multi_checkbox extends NHP_Options{

	/**
	 * Field Constructor.
	 *
	 * Required - must call the parent constructor, then assign field and value to vars, and obviously call the render field function
	 *
	 * @since NHP_Options 1.0
	*/
	function __construct($field = array(), $value ='', $parent){

		parent::__construct($parent->sections, $parent->args, $parent->extra_tabs);
		$this->field = $field;
		$this->value = $value;
		//$this->render();

	}//function

	/**
	 * Field Render Function.
	 *
	 * Takes the vars and outputs the HTML for the field in the settings
	 *
	 * @since NHP_Options 1.0
	*/
	function render(){

		$class = (isset($this->field['class']))?$this->field['class']:'regular-text';

		echo '<fieldset>';

			foreach($this->field['options'] as $k => $v){

				$this->value[$k] = (isset($this->value[$k]))?$this->value[$k]:'';

				echo 'field['id'].'_'.array_search($k,array_keys($this->field['options'])).'">';
				echo '<input type="checkbox" id="'.$this->field['id'].'_'.array_search($k,array_keys($this->field['options'])).'" name="'.$this->args['opt_name'].'['.$this->field['id'].']['.$k.']" '.$class.' value="1" '.checked($this->value[$k], '1', false).'/>';
				echo ' '.$v.'
';

			}//foreach

		echo (isset($this->field['desc']) && !empty($this->field['desc']))?''.$this->field['desc'].'':'';

		echo '</fieldset>';

	}//function

}//class
?>


text:
A [Sublime Text](http://www.sublimetext.com) plug-in to show information about files in a git repository:

1. _Gutter Icons_ indicating inserted, modified or deleted lines
2. _Diff Popup_ with details about modified lines
3. _Status Bar Text_ with information about file and repository

and provides some commands like:

1. _Goto Change_ to navigate between modified lines
2. _Copy from Commit_ to copy the original content from the commit
3. _Revert to Commit_ to revert a modified hunk to the original state in a commit

## Gutter Icons & Status Bar Text

![screenshot](docs/assets/images/gutter_and_status.gif)

The icons of the default theme have the following meaning:

 Icon          | Description
:-------------:|-------------------------
![inserted][]  | inserted line
![changed][]   | modified line
![deleted][]   | deleted region borders
![ignored][]   | ignored file
![untracked][] | untracked file

[changed]: <docs/assets/images/gutter_changed.png>
[deleted]: <docs/assets/images/gutter_deleted.png>
[ignored]: <docs/assets/images/gutter_ignored.png>
[inserted]: <docs/assets/images/gutter_inserted.png>
[untracked]: <docs/assets/images/gutter_untracked.png>

## Diff Popup

The diff popup shows the original content from the commit or the differences between it and the working content.

![diff_popup_screenshot](docs/assets/images/diff_popup.gif)

The toolbar provides some commands to interact with or modify the changes.

 symbol | meaning of the symbol
 :-----:| ---------------------------------------
 ×      | close the popup
 ⤒      | goto to first change
 ↑      | goto to previous change
 ↓      | goto to next change
 ≈, ≉   | enable/disable difference highlighting
 ⎘      | copy the original content from the commit
 ⟲      | revert a modified hunk to the original state in a commit

## Documentation

Please read https://jisaacks.github.io/GitGutter/ for detailed information about

- [Installation](https://jisaacks.github.io/GitGutter/install)
- [Usage](https://jisaacks.github.io/GitGutter/usage)
- [Settings](https://jisaacks.github.io/GitGutter/settings)
- [Troubleshooting](https://jisaacks.github.io/GitGutter/troubleshooting)


text:
/**
	@author Ben Lau <xbenlau@gmail.com>
 */

#include <QtCore>
#include "dqstream.h"

DQStream::DQStream()
{
    m_model = 0;
    m_current = 0;
}

DQStream::DQStream(DQAbstractModel* model) {
    m_model = 0;
    m_current = 0;

    open(model);
}

void DQStream::open(DQAbstractModel* model){
    m_model = model;
    m_current = 0;

    if (m_model) {
        DQModelMetaInfo *metaInfo = m_model->metaInfo();
        if (metaInfo->size() == 1) {
            qWarning() << "DQStream::setModel() do not support model with single field of id.";
            m_model = 0;
        }
    }
}

DQAbstractModel* DQStream::model(){
    return m_model;
}

int DQStream::currentField() {
    return m_current;
}

void DQStream::write(const QVariant value) {
    Q_ASSERT(m_model);

    DQModelMetaInfo *metaInfo = m_model->metaInfo();

    if (m_current == 0) // ignore id field
        m_current++;

    metaInfo->setValue(m_model,m_current++,value);

    if (m_current >= metaInfo->size() ) {
        m_current = 0 ; // reset the count to zero.
    }
}

void DQStream::read(QVariant &target) {
    Q_ASSERT(m_model);
    Q_ASSERT(m_model);

    DQModelMetaInfo *metaInfo = m_model->metaInfo();

    if (m_current == 0) // ignore id field
        m_current++;

    target = metaInfo->value(m_model,m_current++);

    if (m_current >= metaInfo->size() ) {
        m_current = 0 ; // reset the count to zero.
    }
}

void DQStream::close() {
    m_current = 0;
    m_model = 0;
}

DQStream& DQStream::operator<< (const QVariant value){
    write(value);
    return (*this);
}

DQStream& DQStream::operator>> (QVariant &target){
    read(target);
    return (*this);
}

DQStream& DQStream::operator>> (QString& target){
    QVariant v;
    read(v);
    target = v.toString();
    return (*this);
}

DQStream& DQStream::operator>> (int& target) {
    QVariant v;
    read(v);
    target = v.toInt();
    return (*this);
}

DQStream& DQStream::operator>> (double& target) {
    QVariant v;
    read(v);
    target = v.toDouble();
    return (*this);
}

DQStream& DQStream::operator>> (QDateTime& target) {
    QVariant v;
    read(v);
    target = v.toDateTime();
    return (*this);
}


text:
import org.jspecify.nullness.NullMarked;

@NullMarked
class ClassLiteral {
  Object x0() {
    return ClassLiteral.class;
  }

  Object x1() {
    return int.class;
  }

  Object x2() {
    return void.class;
  }
}