solenv/bin/modules/par2script/work.pm

   1 #
   2 # This file is part of the LibreOffice project.
   3 #
   4 # This Source Code Form is subject to the terms of the Mozilla Public
   5 # License, v. 2.0. If a copy of the MPL was not distributed with this
   6 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7 #
   8 # This file incorporates work covered by the following license notice:
   9 #
  10 #   Licensed to the Apache Software Foundation (ASF) under one or more
  11 #   contributor license agreements. See the NOTICE file distributed
  12 #   with this work for additional information regarding copyright
  13 #   ownership. The ASF licenses this file to you under the Apache
  14 #   License, Version 2.0 (the "License"); you may not use this file
  15 #   except in compliance with the License. You may obtain a copy of
  16 #   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17 #
  18
  19
  20 package par2script::work;
  21
  22 use par2script::globals;
  23 use par2script::remover;
  24
  25 ############################################
  26 # par2script working module
  27 ############################################
  28
  29 sub analyze_comma_separated_list
  30 {
  31     my ($list, $listref) = @_;  # second parameter is optional
  32
  33     my @list = ();
  34     my $locallistref;
  35
  36     if (!( $listref )) { $locallistref = \@list; }
  37     else { $locallistref = $listref; }
  38
  39     par2script::remover::remove_leading_and_ending_comma(\$list);
  40     par2script::remover::remove_leading_and_ending_whitespaces(\$list);
  41
  42     while ( $list =~ /^\s*(.*?)\s*\,\s*(.*)\s*$/ )
  43     {
  44         my $oneentry = $1;
  45         $list = $2;
  46         par2script::remover::remove_leading_and_ending_whitespaces(\$oneentry);
  47         push(@{$locallistref}, $oneentry);
  48     }
  49
  50     # the last entry
  51
  52     par2script::remover::remove_leading_and_ending_whitespaces(\$list);
  53     push(@{$locallistref}, $list);
  54
  55     return $locallistref;
  56 }
  57
  58 ############################################
  59 # setting list of include paths
  60 ############################################
  61
  62 sub setincludes
  63 {
  64     my ($list) = @_;
  65
  66     # input is the comma separated list of include paths
  67
  68     my $includes = analyze_comma_separated_list($list);
  69
  70     return $includes;
  71 }
  72
  73 ############################################
  74 # setting list of all par files
  75 ############################################
  76
  77 sub setparfiles
  78 {
  79     my ($filename) = @_;
  80
  81     # input is the name of the list file
  82     $filename =~ s/\@//;    # removing the leading \@
  83
  84     my $filecontent = par2script::files::read_file($filename);
  85
  86     my @parfiles = ();
  87     my $parfilesref = \@parfiles;
  88
  89     foreach ( @{$filecontent} ) { $parfilesref = analyze_comma_separated_list($_, $parfilesref); }
  90
  91     return $parfilesref;
  92 }
  93
  94 ############################################
  95 # finding the correct include path
  96 # for the par files
  97 ############################################
  98
  99 sub make_complete_paths_for_parfiles
 100 {
 101     my ($parfiles, $includes) = @_;
 102
 103     my $oneparfile;
 104
 105     foreach $oneparfile ( @{$parfiles} )
 106     {
 107         my $foundparfile = 0;
 108         my $includepath;
 109
 110         foreach $includepath ( @{$includes} )
 111         {
 112             my $parfile = "$includepath/$oneparfile";
 113
 114             if ( -f $parfile )
 115             {
 116                 $foundparfile = 1;
 117                 $oneparfile = $parfile;
 118                 last;
 119             }
 120         }
 121
 122         if ( ! $foundparfile )
 123         {
 124             die "ERROR: Could not find parfile ${$parfiles}[$i] in includes paths: $par2script::globals::includepathlist !\n";
 125         }
 126     }
 127 }
 128
 129 ######################################################
 130 # collecting one special item in the par files and
 131 # including it into the "definitions" hash
 132 ######################################################
 133
 134 sub collect_definitions
 135 {
 136     my ($parfilecontent) = @_;
 137
 138     my $multidefinitionerror = 0;
 139     my @multidefinitiongids = ();
 140
 141     my %itemhash;
 142
 143     # create empty item hashes
 144     foreach $oneitem ( @par2script::globals::allitems ) {
 145     my %items;
 146         $par2script::globals::definitions{$oneitem} = \%items;
 147     }
 148
 149     for ( my $i = 0; $i <= $#{$parfilecontent}; $i++ )
 150     {
 151     my $line = ${$parfilecontent}[$i];
 152     my $oneitem, $gid;
 153
 154     $line =~ /^\s*$/ && next; # skip blank lines
 155
 156     # lines should be well formed:
 157     if ($line =~ m/^\s*(\w+)\s+(\w+)\s*$/)
 158     {
 159         $oneitem = $1;
 160         $gid = $2;
 161     } else {
 162         chomp ($line);
 163         my $invalid = $line;
 164         $invalid =~ s/[\s\w]*//g;
 165         par2script::exiter::exit_program("ERROR: malformed par file, invalid character '$invalid', expecting <token> <gid> but saw '$line'", "test_par_syntax");
 166     }
 167 #   print STDERR "line '$line' -> '$oneitem' '$gid'\n";
 168
 169     # hunt badness variously
 170     if ( ! defined $par2script::globals::definitions{$oneitem} )
 171     {
 172         par2script::exiter::exit_program("ERROR: invalid scp2 fragment item type '$oneitem' in line: '$line'", "test_par_syntax");
 173     }
 174
 175     # no hyphen allowed in gids -> cannot happen here because (\w+) is required for gids
 176     if ( $gid =~ /-/ ) { par2script::exiter::exit_program("ERROR: No hyphen allowed in global id: $gid", "test_of_hyphen"); }
 177
 178     my %oneitemhash;
 179
 180     while (! ( ${$parfilecontent}[$i] =~ /^\s*End\s*$/i ) )
 181     {
 182         if ( ${$parfilecontent}[$i] =~ /^\s*(.+?)\s*\=\s*(.+?)\s*\;\s*$/ )  # only oneliner!
 183         {
 184         $itemkey = $1;
 185         $itemvalue = $2;
 186
 187         if ( $oneitem eq "Directory" ) { if ( $itemkey =~ "DosName" ) { $itemkey =~ s/DosName/HostName/; } }
 188         if (( $oneitem eq "Directory" ) || ( $oneitem eq "File" ) || ( $oneitem eq "Unixlink" )) { if ( $itemvalue eq "PD_PROGDIR" ) { $itemvalue = "PREDEFINED_PROGDIR"; }}
 189         if (( $itemkey eq "Styles" ) && ( $itemvalue =~ /^\s*(\w+)(\s*\;\s*)$/ )) { $itemvalue = "($1)$2"; }
 190         elsif ( $itemkey eq "Files" ) # filter out empty file records, as they mess up assignment to modules
 191         {
 192             $itemvalue =~ /^\(([^)]*)\)$/;
 193             $itemvalue = '(' . join( ',', grep( !/^$/, split( ',', $1 ) ) ) . ')';
 194         }
 195
 196         $oneitemhash{$itemkey} = $itemvalue;
 197         }
 198         $i++;
 199     }
 200
 201     # test of uniqueness
 202     if ( defined ($par2script::globals::definitions{$oneitem}->{$gid}) )
 203     {
 204         $multidefinitionerror = 1;
 205         push(@multidefinitiongids, $gid);
 206     }
 207
 208     $par2script::globals::definitions{$oneitem}->{$gid} = \%oneitemhash;
 209     }
 210
 211     if ( $multidefinitionerror ) { par2script::exiter::multidefinitionerror(\@multidefinitiongids); }
 212
 213     # foreach $key (keys %par2script::globals::definitions)
 214     # {
 215     #   print "Key: $key \n";
 216     #
 217     #   foreach $key (keys %{$par2script::globals::definitions{$key}})
 218     #   {
 219     #       print "\t$key \n";
 220     #   }
 221     # }
 222 }
 223
 224 ######################################################
 225 # Filling content into the script
 226 ######################################################
 227
 228 sub put_oneitem_into_script
 229 {
 230     my ( $script, $item, $itemhash, $itemkey ) = @_;
 231
 232     push(@{$script}, "$item $itemkey\n" );
 233     my $content = "";
 234     foreach $content (sort keys %{$itemhash->{$itemkey}}) { push(@{$script}, "\t$content = $itemhash->{$itemkey}->{$content};\n" ); }
 235     push(@{$script}, "End\n" );
 236     push(@{$script}, "\n" );
 237 }
 238
 239 ######################################################
 240 # Creating the script
 241 ######################################################
 242
 243 sub create_script
 244 {
 245     my @script = ();
 246     my $oneitem;
 247
 248     foreach $oneitem ( @par2script::globals::allitems )
 249     {
 250         if ( exists($par2script::globals::definitions{$oneitem}) )
 251         {
 252             if ( $oneitem eq "Shortcut" ) { next; } # "Shortcuts" after "Files"
 253
 254             if (( $oneitem eq "Module" ) || ( $oneitem eq "Directory" )) { write_sorted_items(\@script, $oneitem); }
 255             else { write_unsorted_items(\@script, $oneitem); }
 256         }
 257     }
 258
 259     return \@script;
 260 }
 261
 262 ######################################################
 263 # Adding script content for the unsorted items
 264 ######################################################
 265
 266 sub write_unsorted_items
 267 {
 268     my ( $script, $oneitem ) = @_;
 269
 270     my $itemhash = $par2script::globals::definitions{$oneitem};
 271
 272     my $itemkey = "";
 273     foreach $itemkey (sort keys %{$itemhash})
 274     {
 275         put_oneitem_into_script($script, $oneitem, $itemhash, $itemkey);
 276
 277         # special handling for Shortcuts after Files
 278         if (( $oneitem eq "File" ) && ( exists($par2script::globals::definitions{"Shortcut"}) ))
 279         {
 280             my $shortcutkey;
 281             foreach $shortcutkey ( keys %{$par2script::globals::definitions{"Shortcut"}} )
 282             {
 283                 if ( $par2script::globals::definitions{"Shortcut"}->{$shortcutkey}->{'FileID'} eq $itemkey )
 284                 {
 285                     put_oneitem_into_script($script, "Shortcut", $par2script::globals::definitions{"Shortcut"}, $shortcutkey);
 286
 287                     # and Shortcut to Shortcut also
 288                     my $internshortcutkey;
 289                     foreach $internshortcutkey ( keys %{$par2script::globals::definitions{"Shortcut"}} )
 290                     {
 291                         if ( $par2script::globals::definitions{"Shortcut"}->{$internshortcutkey}->{'ShortcutID'} eq $shortcutkey )
 292                         {
 293                             put_oneitem_into_script($script, "Shortcut", $par2script::globals::definitions{"Shortcut"}, $internshortcutkey);
 294                         }
 295                     }
 296                 }
 297             }
 298         }
 299     }
 300 }
 301
 302 ######################################################
 303 # Collecting all children of a specified parent
 304 ######################################################
 305
 306 sub collect_children
 307 {
 308     my ( $itemhash, $parent, $order ) = @_;
 309
 310     my $item;
 311     foreach $item ( sort keys %{$itemhash} )
 312     {
 313         if ( $itemhash->{$item}->{'ParentID'} eq $parent )
 314         {
 315             push(@{$order}, $item);
 316             my $newparent = $item;
 317             collect_children($itemhash, $newparent, $order);
 318         }
 319     }
 320 }
 321
 322 ######################################################
 323 # Adding script content for the sorted items
 324 ######################################################
 325
 326 sub write_sorted_items
 327 {
 328     my ( $script, $oneitem ) = @_;
 329
 330     my $itemhash = $par2script::globals::definitions{$oneitem};
 331
 332     my @itemorder = ();
 333     my @startparents = ();
 334
 335     if ( $oneitem eq "Module" ) { push(@startparents, ""); }
 336     elsif ( $oneitem eq "Directory" ) { push(@startparents, "PREDEFINED_PROGDIR"); }
 337     else { die "ERROR: No root parent defined for item type $oneitem !\n"; }
 338
 339     # supporting more than one toplevel item
 340     my $parent;
 341     foreach $parent ( @startparents ) { collect_children($itemhash, $parent, \@itemorder); }
 342
 343     my $itemkey;
 344     foreach $itemkey ( @itemorder ) { put_oneitem_into_script($script, $oneitem, $itemhash, $itemkey); }
 345 }
 346
 347 #######################################################################
 348 # Collecting all assigned gids of the type "item" from the modules
 349 # in the par files. Using a hash!
 350 #######################################################################
 351
 352 sub collect_assigned_gids
 353 {
 354     my $allmodules = $par2script::globals::definitions{'Module'};
 355
 356     my $item;
 357     foreach $item ( @par2script::globals::items_assigned_at_modules )
 358     {
 359         if ( ! exists($par2script::globals::searchkeys{$item}) ) { par2script::exiter::exit_program("ERROR: Unknown type \"$item\" at modules.", "collect_assigned_gids"); }
 360
 361         my $searchkey = $par2script::globals::searchkeys{$item};
 362
 363         my %assignitems = ();
 364         my $modulegid = "";
 365
 366         foreach $modulegid (keys %{$allmodules} )
 367         {
 368             # print "Module $modulegid\n";
 369             # my $content = "";
 370             # foreach $content (sort keys %{$allmodules->{$modulegid}}) { print "\t$content = $allmodules->{$modulegid}->{$content};\n"; }
 371             # print "End\n";
 372             # print "\n";
 373
 374             if ( exists($allmodules->{$modulegid}->{$searchkey}) )
 375             {
 376                 my $list = $allmodules->{$modulegid}->{$searchkey};
 377                 if ( $list =~ /^\s*\((.*?)\)\s*(.*?)\s*$/ ) { $list = $1; }
 378                 else { par2script::exiter::exit_program("ERROR: Invalid module list: $list", "collect_assigned_gids"); }
 379                 my $allassigneditems = par2script::converter::convert_stringlist_into_array_2($list, ",");
 380
 381                 my $gid;
 382                 foreach $gid ( @{$allassigneditems} )
 383                 {
 384                     if ( exists($assignitems{$gid}) ) { $assignitems{$gid} = $assignitems{$gid} + 1; }
 385                     else { $assignitems{$gid} = 1; }
 386                 }
 387             }
 388         }
 389
 390         $par2script::globals::assignedgids{$item} = \%assignitems;
 391     }
 392 }
 393
 394 ##################################################
 395 # Collecting the content of all par files.
 396 # Then the files do not need to be opened twice.
 397 ##################################################
 398
 399 sub read_all_parfiles
 400 {
 401     my ($parfiles) = @_;
 402
 403     my @parfilecontent = ();
 404     my $parfilename;
 405
 406     foreach $parfilename ( @{$parfiles} )
 407     {
 408         my $parfile = par2script::files::read_file($parfilename);
 409         foreach ( @{$parfile} ) { push(@parfilecontent, $_); }
 410         push(@parfilecontent, "\n");
 411     }
 412
 413     return \@parfilecontent;
 414 }
 415
 416 1;