Class: Ripper

Inherits:

Object

• Object
• Ripper

Defined in:

parse.c

Constant Summary

Version =

version of Ripper

rb_usascii_str_new2(RIPPER_VERSION)

Class Method Summary

• .dedent_string(input, width) ⇒ Object

Instance Method Summary

• #column ⇒ Integer

  Return column number of current parsing line.

• #dedent_string(input, width) ⇒ Object private
• #encoding ⇒ Encoding

  Return encoding of the source.

• #end_seen? ⇒ Boolean

  Return true if parsed source ended by _END_.

• #error? ⇒ Boolean

  Return true if parsed source has errors.

• #filename ⇒ String

  Return current parsing filename.

• #new(src, filename = "(ripper)", lineno = 1) ⇒ Object constructor

  Create a new Ripper object.

• #lineno ⇒ Integer

  Return line number of current parsing line.

• #parse ⇒ Object

  Start parsing and returns the value of the root action.

• #yydebug ⇒ Boolean

  Get yydebug.

• #yydebug=(flag) ⇒ Object

  Set yydebug.

Constructor Details

#new(src, filename = "(ripper)", lineno = 1) ⇒ Object

Create a new Ripper object. src must be a String, an IO, or an Object which has #gets method.

This method does not starts parsing. See also Ripper#parse and Ripper.parse.

# File 'parse.c', line 17897

static VALUE
ripper_initialize(int argc, VALUE *argv, VALUE self)
{
    struct parser_params *parser;
    VALUE src, fname, lineno;

    TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
    rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
    if (RB_TYPE_P(src, T_FILE)) {
        lex_gets = ripper_lex_get_generic;
    }
    else {
        StringValue(src);
        lex_gets = lex_get_str;
    }
    lex_input = src;
    parser->eofp = 0;
    if (NIL_P(fname)) {
        fname = STR_NEW2("(ripper)");
	OBJ_FREEZE(fname);
    }
    else {
        StringValue(fname);
	fname = rb_str_new_frozen(fname);
    }
    parser_initialize(parser);

    ruby_sourcefile_string = fname;
    ruby_sourcefile = RSTRING_PTR(fname);
    ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;

    return Qnil;
}

Class Method Details

.dedent_string(input, width) ⇒ Object

# File 'parse.c', line 13255

static VALUE
parser_dedent_string(VALUE self, VALUE input, VALUE width)
{
    char *str;
    long len;
    int wid, col;

    StringValue(input);
    wid = NUM2UINT(width);
    rb_str_modify(input);
    RSTRING_GETMEM(input, str, len);
    col = dedent_pos(str, len, wid);
    MEMMOVE(str, str + col, char, len - col);
    rb_str_set_len(input, len - col);
    return INT2NUM(col);
}

Instance Method Details

#column ⇒ Integer

Return column number of current parsing line. This number starts from 0.

Returns:

• (Integer)

# File 'parse.c', line 17992

static VALUE
ripper_column(VALUE self)
{
    struct parser_params *parser;
    long col;

    TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
    if (!ripper_initialized_p(parser)) {
        rb_raise(rb_eArgError, "method called for uninitialized object");
    }
    if (NIL_P(parser->parsing_thread)) return Qnil;
    col = parser->tokp - lex_pbeg;
    return LONG2NUM(col);
}

#dedent_string(input, width) ⇒ Object (private)

# File 'parse.c', line 13255

static VALUE
parser_dedent_string(VALUE self, VALUE input, VALUE width)
{
    char *str;
    long len;
    int wid, col;

    StringValue(input);
    wid = NUM2UINT(width);
    rb_str_modify(input);
    RSTRING_GETMEM(input, str, len);
    col = dedent_pos(str, len, wid);
    MEMMOVE(str, str + col, char, len - col);
    rb_str_set_len(input, len - col);
    return INT2NUM(col);
}

#encoding ⇒ Encoding

Return encoding of the source.

Returns:

• (Encoding)

# File 'parse.c', line 17515

VALUE
rb_parser_encoding(VALUE vparser)
{
    struct parser_params *parser;

    TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
    return rb_enc_from_encoding(current_enc);
}

#end_seen? ⇒ Boolean

Return true if parsed source ended by _END_.

Returns:

• (Boolean)

Returns:

• (Boolean)

# File 'parse.c', line 17500

VALUE
rb_parser_end_seen_p(VALUE vparser)
{
    struct parser_params *parser;

    TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
    return ruby__end__seen ? Qtrue : Qfalse;
}

#error? ⇒ Boolean

Return true if parsed source has errors.

Returns:

• (Boolean)

Returns:

• (Boolean)

# File 'parse.c', line 17484

static VALUE
ripper_error_p(VALUE vparser)
{
    struct parser_params *parser;

    TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
    return parser->error_p ? Qtrue : Qfalse;
}

#filename ⇒ String

Return current parsing filename.

Returns:

• (String)

# File 'parse.c', line 18013

static VALUE
ripper_filename(VALUE self)
{
    struct parser_params *parser;

    TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
    if (!ripper_initialized_p(parser)) {
        rb_raise(rb_eArgError, "method called for uninitialized object");
    }
    return ruby_sourcefile_string;
}

#lineno ⇒ Integer

Return line number of current parsing line. This number starts from 1.

Returns:

• (Integer)

# File 'parse.c', line 18032

static VALUE
ripper_lineno(VALUE self)
{
    struct parser_params *parser;

    TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
    if (!ripper_initialized_p(parser)) {
        rb_raise(rb_eArgError, "method called for uninitialized object");
    }
    if (NIL_P(parser->parsing_thread)) return Qnil;
    return INT2NUM(ruby_sourceline);
}

#parse ⇒ Object

Start parsing and returns the value of the root action.

# File 'parse.c', line 17964

static VALUE
ripper_parse(VALUE self)
{
    struct parser_params *parser;

    TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
    if (!ripper_initialized_p(parser)) {
        rb_raise(rb_eArgError, "method called for uninitialized object");
    }
    if (!NIL_P(parser->parsing_thread)) {
        if (parser->parsing_thread == rb_thread_current())
            rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
        else
            rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
    }
    parser->parsing_thread = rb_thread_current();
    rb_ensure(ripper_parse0, self, ripper_ensure, self);

    return parser->result;
}

#yydebug ⇒ Boolean

Get yydebug.

Returns:

• (Boolean)

# File 'parse.c', line 17530

VALUE
rb_parser_get_yydebug(VALUE self)
{
    struct parser_params *parser;

    TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
    return yydebug ? Qtrue : Qfalse;
}

#yydebug=(flag) ⇒ Object

Set yydebug.

# File 'parse.c', line 17545

VALUE
rb_parser_set_yydebug(VALUE self, VALUE flag)
{
    struct parser_params *parser;

    TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
    yydebug = RTEST(flag);
    return flag;
}