| 1 | package Syntax::Kamelon::XMLData; | ||
| 2 | |||
| 3 | 12 | ▶ | use strict; |
|
Subroutine
BEGIN: called CC=1 SCAR=0.0
| |||
| 4 | 12 | ▶ | use warnings; |
|
Subroutine
BEGIN: called CC=1 SCAR=0.0
| |||
| 5 | 0 | ▶ | use XML::TokeParser; |
|
Subroutine
BEGIN: called CC=1 SCAR=2.6
| |||
| 6 | |||
| 7 | our $VERSION = '0.23'; | ||
| 8 | |||
| 9 | # my $regchars = "\\^.\$|()[]{}*+?~!%^&/"; | ||
| 10 | |||
| 11 | my %deliminators = ( | ||
| 12 | '.' => 1, | ||
| 13 | '(' => 1, | ||
| 14 | ')' => 1, | ||
| 15 | ':' => 1, | ||
| 16 | '!' => 1, | ||
| 17 | '+' => 1, | ||
| 18 | ',' => 1, | ||
| 19 | '-' => 1, | ||
| 20 | '<' => 1, | ||
| 21 | '=' => 1, | ||
| 22 | '>' => 1, | ||
| 23 | '%' => 1, | ||
| 24 | '&' => 1, | ||
| 25 | '*' => 1, | ||
| 26 | '/' => 1, | ||
| 27 | ';' => 1, | ||
| 28 | '?' => 1, | ||
| 29 | '[' => 1, | ||
| 30 | ']' => 1, | ||
| 31 | '^' => 1, | ||
| 32 | '{' => 1, | ||
| 33 | '|' => 1, | ||
| 34 | '}' => 1, | ||
| 35 | '~' => 1, | ||
| 36 | ' ' => 1, | ||
| 37 | "\\" => 1, | ||
| 38 | "\t" => 1, | ||
| 39 | "\n" => 1, | ||
| 40 | ); | ||
| 41 | my %wordwrapdeliminators = %deliminators; | ||
| 42 | |||
| 43 | sub new { | ||
| 44 | my $proto = shift; | ||
| 45 | my $class = ref($proto) || $proto; | ||
| 46 | my %args = (@_); | ||
| 47 | |||
| 48 | my $file = delete $args{'xmlfile'}; | ||
| 49 | my $self = { | ||
| 50 | ATTRIBUTES => {}, | ||
| 51 | COMMENT => {}, | ||
| 52 | BASECONTEXT => '', | ||
| 53 | CONTEXTDATA => {}, | ||
| 54 | DELIMINATORS => \%deliminators, | ||
| 55 | ADDDELIMINATORS => '', | ||
| 56 | WEAKDELIMINATORS => '', | ||
| 57 | WORDWRAPDELIMINATORS => \%wordwrapdeliminators, | ||
| 58 | FILENAME => $file, | ||
| 59 | KEYWORDSCASE => 'undef', | ||
| 60 | LANGUAGE => {}, | ||
| 61 | LISTS => {}, | ||
| 62 | }; | ||
| 63 | bless ($self, $class); | ||
| 64 | if (defined($file)) { | ||
| 65 | $self->XMLLoad($file); | ||
| 66 | } | ||
| 67 | return $self; | ||
| 68 | } | ||
| 69 | |||
| 70 | |||
| 71 | sub Attributes { | ||
| 72 | my $self = shift; | ||
| 73 | if (@_) { $self->{ATTRIBUTES} = shift; }; | ||
| 74 | return $self->{ATTRIBUTES}; | ||
| 75 | } | ||
| 76 | |||
| 77 | sub BaseContext { | ||
| 78 | my $self = shift; | ||
| 79 | if (@_) { $self->{BASECONTEXT} = shift } | ||
| 80 | return $self->{BASECONTEXT} | ||
| 81 | } | ||
| 82 | |||
| 83 | sub Booleanize { | ||
| 84 | my ($self, $d) = @_; | ||
| 85 | if (lc($d) eq 'true') { $d = 1 }; | ||
| 86 | if (lc($d) eq 'false') { $d = 0 }; | ||
| 87 | if (($d ne 0) and ($d ne 1)) { return undef }; | ||
| 88 | return $d; | ||
| 89 | } | ||
| 90 | |||
| 91 | # sub Clear { | ||
| 92 | # my $self = shift; | ||
| 93 | # $self->{BASECONTEXT} = ''; | ||
| 94 | # $self->{CONTEXTDATA} = {}; | ||
| 95 | # $self->{ADDDELIMINATORS} = ''; | ||
| 96 | # $self->{WEAKDELIMINATORS} = ''; | ||
| 97 | # $self->{FILENAME} = ''; | ||
| 98 | # $self->{ITEMDATA} = {}; | ||
| 99 | # $self->{KEYWORDSCASE} = 1; | ||
| 100 | # $self->{LANGUAGE} = {}; | ||
| 101 | # $self->{LISTS} = {}; | ||
| 102 | # } | ||
| 103 | |||
| 104 | sub Comment { | ||
| 105 | my $self = shift; | ||
| 106 | if (@_) { $self->{COMMENT} = shift; }; | ||
| 107 | return $self->{COMMENT}; | ||
| 108 | } | ||
| 109 | |||
| 110 | sub ContextData { | ||
| 111 | my $self = shift; | ||
| 112 | if (@_) { $self->{CONTEXTDATA} = shift; }; | ||
| 113 | return $self->{CONTEXTDATA}; | ||
| 114 | } | ||
| 115 | |||
| 116 | sub Deliminators { | ||
| 117 | my $self = shift; | ||
| 118 | if (@_) { $self->{DELIMINATORS} = shift } | ||
| 119 | return $self->{DELIMINATORS} | ||
| 120 | } | ||
| 121 | |||
| 122 | sub AdditionalDeliminators { | ||
| 123 | my $self = shift; | ||
| 124 | if (@_) { $self->{ADDDELIMINATORS} = shift } | ||
| 125 | return $self->{ADDDELIMINATORS} | ||
| 126 | } | ||
| 127 | |||
| 128 | sub WeakDeliminators { | ||
| 129 | my $self = shift; | ||
| 130 | if (@_) { $self->{WEAKDELIMINATORS} = shift } | ||
| 131 | return $self->{WEAKDELIMINATORS} | ||
| 132 | } | ||
| 133 | |||
| 134 | sub WordWrapDeliminators { | ||
| 135 | my $self = shift; | ||
| 136 | if (@_) { $self->{WORDWRAPDELIMINATORS} = shift } | ||
| 137 | return $self->{WORDWRAPDELIMINATORS} | ||
| 138 | } | ||
| 139 | |||
| 140 | sub FileName { | ||
| 141 | my $self = shift; | ||
| 142 | if (@_) { $self->{FILENAME} = shift } | ||
| 143 | return $self->{FILENAME} | ||
| 144 | } | ||
| 145 | |||
| 146 | sub GetItems { | ||
| 147 | my ($self, $parser) = @_; | ||
| 148 | my @list = (); | ||
| 149 | while (my $token = $parser->get_token) { | ||
| 150 | if ($token->[0] eq 'S') { | ||
| 151 | my $t = $token->[2]; | ||
| 152 | $t->{'type'} = $token->[1]; | ||
| 153 | my @items = $self->GetItems($parser); | ||
| 154 | if (@items) { | ||
| 155 | $t->{'items'} = \@items | ||
| 156 | } | ||
| 157 | push @list, $t; | ||
| 158 | } elsif ($token->[0] eq 'E') { | ||
| 159 | return @list; | ||
| 160 | } | ||
| 161 | } | ||
| 162 | } | ||
| 163 | |||
| 164 | sub KeywordsCase { | ||
| 165 | my $self = shift; | ||
| 166 | if (@_) { $self->{KEYWORDSCASE} = shift } | ||
| 167 | return $self->{KEYWORDSCASE} | ||
| 168 | } | ||
| 169 | |||
| 170 | |||
| 171 | sub Language { | ||
| 172 | my $self = shift; | ||
| 173 | if (@_) { $self->{LANGUAGE} = shift } | ||
| 174 | return $self->{LANGUAGE} | ||
| 175 | } | ||
| 176 | |||
| 177 | sub Lists { | ||
| 178 | my $self = shift; | ||
| 179 | if (@_) { $self->{LISTS} = shift } | ||
| 180 | return $self->{LISTS} | ||
| 181 | } | ||
| 182 | |||
| 183 | sub MergeAdditionalDeliminators { | ||
| 184 | my ($self, $delim, $additional) = @_; | ||
| 185 | my @a = split(//, $additional); | ||
| 186 | for (@a) { | ||
| 187 | $delim->{$_} = 1 | ||
| 188 | } | ||
| 189 | return $delim | ||
| 190 | } | ||
| 191 | |||
| 192 | sub MergeWeakDeliminators { | ||
| 193 | my ($self, $delim, $weak) = @_; | ||
| 194 | my @w = split(//, $weak); | ||
| 195 | for (@w) { | ||
| 196 | delete $delim->{$_} | ||
| 197 | } | ||
| 198 | return $delim | ||
| 199 | } | ||
| 200 | |||
| 201 | sub Setup {} | ||
| 202 | |||
| 203 | sub Syntax { | ||
| 204 | my $self = shift; | ||
| 205 | return $self->{LANGUAGE}->{name}; | ||
| 206 | } | ||
| 207 | |||
| 208 | sub XMLGetAttribute { | ||
| 209 | my ($self, $token, $parser) = @_; | ||
| 210 | my $style = $token->[2]->{'defStyleNum'}; | ||
| 211 | unless (defined($style)) { | ||
| 212 | warn "undefined style"; | ||
| 213 | $style = ''; | ||
| 214 | }; | ||
| 215 | $style =~ s/^ds//; | ||
| 216 | $self->Attributes->{$token->[2]->{'name'}} = $style; | ||
| 217 | } | ||
| 218 | |||
| 219 | sub XMLGetContext { | ||
| 220 | my ($self, $token, $parser) = @_; | ||
| 221 | my $ctx = delete $token->[2]->{'name'}; | ||
| 222 | unless (defined($ctx)) { $ctx ='noname' }; | ||
| 223 | my $ar = $token->[2]; | ||
| 224 | my %args = %$ar; | ||
| 225 | if ($self->BaseContext eq '') { | ||
| 226 | $self->BaseContext($ctx); | ||
| 227 | } | ||
| 228 | my @items = $self->GetItems($parser); | ||
| 229 | if (@items) { $args{'items'} = \@items }; | ||
| 230 | $self->XMLSetContext($ctx,\%args); | ||
| 231 | } | ||
| 232 | |||
| 233 | sub XMLGetKeywordSettings { | ||
| 234 | my ($self, $token, $parser) = @_; | ||
| 235 | |||
| 236 | my $case = delete $token->[2]->{'casesensitive'}; | ||
| 237 | if (defined($case)) { | ||
| 238 | $case = $self->Booleanize($case); | ||
| 239 | $case = 1 unless defined $case; | ||
| 240 | $self->KeywordsCase($case); | ||
| 241 | } | ||
| 242 | |||
| 243 | my $wdelim = delete $token->[2]->{'weakDeliminator'}; | ||
| 244 | if (defined $wdelim) { | ||
| 245 | $self->WeakDeliminators($wdelim); | ||
| 246 | $self->MergeWeakDeliminators($self->Deliminators, $wdelim); | ||
| 247 | } | ||
| 248 | |||
| 249 | my $adelim = delete $token->[2]->{'additionalDeliminator'}; | ||
| 250 | if (defined $adelim) { | ||
| 251 | $self->AdditionalDeliminators($adelim); | ||
| 252 | $self->MergeAdditionalDeliminators($self->Deliminators, $adelim); | ||
| 253 | } | ||
| 254 | |||
| 255 | my $wrapdelim = delete $token->[2]->{'wordWrapDeliminator '}; | ||
| 256 | if (defined $wrapdelim) { | ||
| 257 | my %wdelim = (); | ||
| 258 | $self->MergeAdditionalDeliminators(\%wdelim, $wrapdelim); | ||
| 259 | $self->WordWrapDeliminators(\%wdelim) ; | ||
| 260 | } | ||
| 261 | } | ||
| 262 | |||
| 263 | sub XMLGetLanguage { | ||
| 264 | my ($self, $token, $parser) = @_; | ||
| 265 | my $args = $token->[2]; | ||
| 266 | $self->Language($args); | ||
| 267 | } | ||
| 268 | |||
| 269 | sub XMLGetList { | ||
| 270 | my ($self, $token, $parser) = @_; | ||
| 271 | my $name = $token->[2]->{'name'}; | ||
| 272 | my @list = (); | ||
| 273 | my $inlist = 1; | ||
| 274 | while ($inlist) { | ||
| 275 | my $ltok = $parser->get_token; | ||
| 276 | if ($ltok->[0] eq 'T') { | ||
| 277 | my $tx = $ltok->[1]; | ||
| 278 | $tx =~ s/^\s+//; | ||
| 279 | $tx =~ s/\s+$//; | ||
| 280 | push @list, $tx; | ||
| 281 | } elsif ($ltok->[0] eq 'E') { | ||
| 282 | if ($ltok->[1] eq 'list') { | ||
| 283 | $self->Lists->{$name} = [ @list ]; | ||
| 284 | $inlist = 0; | ||
| 285 | } | ||
| 286 | } | ||
| 287 | } | ||
| 288 | } | ||
| 289 | |||
| 290 | sub XMLGetComment { | ||
| 291 | my ($self, $token, $parser) = @_; | ||
| 292 | my $incomments = 1; | ||
| 293 | while ($incomments) { | ||
| 294 | my $ltok = $parser->get_token; | ||
| 295 | if ($ltok->[0] eq 'S') { | ||
| 296 | my $data = $ltok->[2]; | ||
| 297 | my $name = $data->{'name'}; | ||
| 298 | my $start = $data->{'start'}; | ||
| 299 | my $end = $data->{'end'}; | ||
| 300 | $self->Comment->{$name} = [$start, $end] | ||
| 301 | } elsif ($ltok->[0] eq 'E') { | ||
| 302 | if ($ltok->[1] eq 'comments') { | ||
| 303 | $incomments = 0; | ||
| 304 | } | ||
| 305 | } | ||
| 306 | } | ||
| 307 | } | ||
| 308 | |||
| 309 | my %xmlmethods = ( | ||
| 310 | context => 'XMLGetContext', | ||
| 311 | itemData => 'XMLGetAttribute', | ||
| 312 | keywords => 'XMLGetKeywordSettings', | ||
| 313 | language => 'XMLGetLanguage', | ||
| 314 | list => 'XMLGetList', | ||
| 315 | comments => 'XMLGetComment' | ||
| 316 | ); | ||
| 317 | |||
| 318 | sub XMLLoad { | ||
| 319 | my ($self, $file) = @_; | ||
| 320 | unless (open KATE, "<$file") { | ||
| 321 | warn "cannot open $file"; | ||
| 322 | return | ||
| 323 | }; | ||
| 324 | # $self->Clear; | ||
| 325 | my $parser = new XML::TokeParser(\*KATE, Noempty => 1); | ||
| 326 | while (my $token = $parser->get_token) { | ||
| 327 | if ($token->[0] eq 'S') { | ||
| 328 | my $tag = $token->[1]; | ||
| 329 | if (my $method = $xmlmethods{$tag}) { | ||
| 330 | my $call = $self->can($method); | ||
| 331 | &$call($self, $token, $parser); | ||
| 332 | } | ||
| 333 | } | ||
| 334 | } | ||
| 335 | close KATE; | ||
| 336 | $self->FileName($file); | ||
| 337 | } | ||
| 338 | |||
| 339 | sub XMLSetContext { | ||
| 340 | my ($self, $context, $data) = @_; | ||
| 341 | my $path = $self->Syntax . "::$context"; | ||
| 342 | $data->{path} = $path; | ||
| 343 | my $i = $data->{items}; | ||
| 344 | my $num = 1; | ||
| 345 | foreach my $item (@$i) { | ||
| 346 | $item->{path} = $path . "::$num"; | ||
| 347 | $num ++; | ||
| 348 | } | ||
| 349 | $self->ContextData->{$context} = $data; | ||
| 350 | } | ||
| 351 | |||
| 352 | 1; | ||
| 353 | |||