my $filecontent = "{type line} {series {{1 {{x_data {1 2 3 4 5}} {y";

my ( $xdata ) = $filecontent =~ / x_data .*? ({.*?})/xms;
my @x;
while ($xdata =~ /(\d+)/g) {
   push @x, $1;
}
[download]

Your syntax and data structure looks very much like an s-expression (or Lisp list) with some minor differences: like braces instead of parentheses.

The following is a partial solution to your question after massaging the input a little bit. First, braces are replaced by parentheses. Then, all underscores have been replaced by hyphens (this is due to a current limitation of the module used below). And the input file looks like this:

(chart ((1 ((title title-1) (xlable X-lab) (ylable Y-lab) (description
+ desc1) (type line) (series ((1 ((x-data (1 2 3 4 5)) (y-data (20 90 
+60 50 30))))))))))
[download]

There is in CPAN a quite recent module named Data::SExpression (and there is some problem with the current version 0.33 and so I recommend installing the former — for example, say install NELHAGE/Data-SExpression-0.32.tar.gz in the CPAN shell instead of just install Data::SExpression). This module is able to parse the input above.

But that does not mean it would turn into a handy data structure. Instead it is all composed of array refs that made things quite difficult to access.

[
  "chart",
  [
    [
      1,
      [
        ["title", "title-1"],
        ["xlable", "X-lab"],
        ["ylable", "Y-lab"],
        ["description", "desc1"],
        ["type", "line"],
        [
          "series",
          [
            [
              1,
              [["x-data", [1, 2, 3, 4, 5]], ["y-data", [20, 90, 60, 50
+, 30]]],
            ],
          ],
        ],
      ],
    ],
  ],
]
[download]

Making some assumptions on your data, I wrote some code to turn that into a nice hash of hashes. Like this:

{
  chart => {
        description => "desc1",
        series      => { "x-data" => [1, 2, 3, 4, 5], 
                         "y-data" => [20, 90, 60, 50, 30] },
        title       => "title-1",
        type        => "line",
        xlable      => "X-lab",
        ylable      => "Y-lab",
      },
}
[download]

Now i want to get the value of x_data (1 2 3 4 5) and y_data (20 90 60 50 30)

use Data::Dump qw(dump);
print "x_data: ", dump($keyed_list->{chart}->{series}->{"x-data"}), "\
+n";
print "y_data: ", dump($keyed_list->{chart}->{series}->{"y-data"}), "\
+n";

# which outputs
#x_data: [1, 2, 3, 4, 5]
#y_data: [20, 90, 60, 50, 30]
[download]

$line = "{chart {{1 {{title title_1} {xlable X-lab} {ylable Y-lab} {de
+scription desc1} {type line} {series {{1 {{x_data {1 2 3 4 5}} {y_dat
+a {20 90 60 50 30}}}}}}}}}}";


$line =~ /x_data\s+\{(.*?)\}/;
print "X DATA : $1 \n";

$line =~ /y_data\s+\{(.*?)\}/;

print "Y DATA : $1 \n";
[download]

  if ($line =~ /x_data\s+\{(.*?)\}/) {
       print "X DATA : $1 \n";
  }
  if ($line =~ /y_data\s+\{(.*?)\}/) {
       print "Y DATA : $1 \n";
  }
[download]

Welcome to the Monastery, mc_pandey

As you can see from the comments above, you presented incomplete information which forced the brethern to guess at what you really want.

Please see How do I post a question effectively?... and, re formatting, Writeup Formatting Tips. Each will help you have a more productive and pleasant experience here.

I've had Text::Balanced listed as something I want to look at for some time now... I'm not sure how it compares to Parse::RecDescent above, but I mean to compare them one day. For all I know Text::Balanced uses Parse::RecDescent...

Just because it's possible, here a self-contained parser to convert the string into an AoA in the sense of ferreira above

use strict;
use warnings;
use Data::Dumper;

# read text from DATA
my $text = do { local $/; <DATA> };

# parse text and convert to AoA
my @stack;
while ($text =~ m/\G([\w-]+|.)/sg) {
    my $tok = $1;
    if ($tok eq '{' or $tok =~ /^\w/) {
        push @stack, $tok;
    }
    elsif ($tok eq '}') {    # stack: ... '{' key val(s)
        my $arr = [];
        while ($stack[-1] ne '{') {
            unshift @$arr, pop @stack;
        }
        pop @stack; # '{'
        push @stack, $arr;
    }
}
print Dumper(\@stack);
__DATA__
{chart { {1 { {title title_1} {xlable X-lab} {ylable Y-lab}
{description desc1} {type line} {series { {1 { {x_data {1 2 3 4 5} }
{y_data {20 90 60 50 30}} } } } } } } } }
[download]

Of course, well-formedness is not tested but just assumed. So no reasonable behaviour, when the input does not conform to the formatting assumptions.

Trying to build the conversion to AoH into this …