package ProjectCreator;

use strict;

use FileHandle;

use File::Path;

use mpc_debug;

use Creator;

use TemplateInputReader;

use TemplateParser;

use FeatureParser;

use CommandHelper;

use Data::Dumper;

use vars qw(@ISA);

@ISA = qw(Creator);

my $BaseClassExtension = 'mpb';

my $ProjectCreatorExtension = 'mpc';

my $TemplateExtension = 'mpd';

my $TemplateInputExtension = 'mpt';

my $static_libs_feature = 'static_libs_only';

my %validNames = ('after' => 1,

'avoids' => 3,

'custom_only' => 1,

'dllout' => 1,

'dynamicflags' => 3,

'exename' => 1,

'exeout' => 1,

'includes' => 3,

'libout' => 1,

'libpaths' => 3,

'libs' => 2,

'lit_libs' => 2,

'macros' => 3,

'managed' => 1,

'pch_header' => 1,

'pch_source' => 1,

'postbuild' => 5,

'postclean' => 5,

'prebuild' => 5,

'pure_libs' => 2,

'recurse' => 1,

'recursive_includes' => 3,

'recursive_libpaths' => 3,

'requires' => 3,

'sharedname' => 1,

'staticflags' => 3,

'staticname' => 1,

'tagchecks' => 1,

'tagname' => 1,

'version' => 1,

'webapp' => 1,

);

my %customDefined = ('automatic_in' => 0x04,

'automatic_out' => 0x04,

'command' => 0x14,

'commandflags' => 0x14,

'dependent' => 0x14,

'dependent_libs' => 0x14,

'precommand' => 0x14,

'postcommand' => 0x14,

'inputext' => 0x01,

'libpath' => 0x04,

'output_follows_input' => 0x04,

'output_option' => 0x14,

'pch_postrule' => 0x04,

'pre_extension' => 0x08,

'source_pre_extension' => 0x08,

'template_pre_extension' => 0x08,

'header_pre_extension' => 0x08,

'inline_pre_extension' => 0x08,

'documentation_pre_extension' => 0x08,

'resource_pre_extension' => 0x08,

'generic_pre_extension' => 0x08,

'pre_filename' => 0x08,

'source_pre_filename' => 0x08,

'template_pre_filename' => 0x08,

'header_pre_filename' => 0x08,

'inline_pre_filename' => 0x08,

'documentation_pre_filename' => 0x08,

'resource_pre_filename' => 0x08,

'generic_pre_filename' => 0x08,

'pre_dirname' => 0x08,

'source_pre_dirname' => 0x08,

'template_pre_dirname' => 0x08,

'header_pre_dirname' => 0x08,

'inline_pre_dirname' => 0x08,

'documentation_pre_dirname' => 0x08,

'resource_pre_dirname' => 0x08,

'generic_pre_dirname' => 0x08,

'source_outputext' => 0x0a,

'template_outputext' => 0x0a,

'header_outputext' => 0x0a,

'inline_outputext' => 0x0a,

'documentation_outputext' => 0x0a,

'resource_outputext' => 0x0a,

'generic_outputext' => 0x0a,

);

my %custom = ('command' => 1,

'commandflags' => 1,

'dependent' => 1,

'dependent_libs'=> 1,

'gendir' => 0,

'precommand' => 1,

'postcommand' => 1,

);

my @default_matching_assignments = ('recurse',

);

my %specialComponents = ('header_files' => 1,

'inline_files' => 1,

'template_files' => 1,

);

my %sourceComponents = ('source_files' => 1,

'template_files' => 1,

);

my $defgroup = 'default_group';

my $grouped_key = 'grouped_';

my $tikey = '/ti/';

my $generic_key = 'generic_files';

use constant PROJECT_NAME => 0;

use constant DEPENDENCIES => 1;

use constant PROJECT_GUID => 2;

use constant LANGUAGE => 3;

use constant CUSTOM_ONLY => 4;

use constant NO_CROSS_COMPILE => 5;

use constant MANAGED_PROJECT => 6;

use constant MAKE_GROUP => 7;

use constant CONFIGURATIONS => 8;

my $cppresource = 'resource_files';

my %cppvc = ('source_files' => [ "\\.cpp", "\\.cxx", "\\.cc", "\\.c", "\\.C", ],

'template_files' => [ "_T\\.cpp", "_T\\.cxx", "_T\\.cc", "_T\\.c", "_T\\.C", "_t\\.cpp", "_t\\.cxx", "_t\\.cc", "_t\\.c", "_t\\.C", "\\.tpp" ],

'header_files' => [ "\\.h", "\\.hpp", "\\.hxx", "\\.hh", ],

'inline_files' => [ "\\.i", "\\.ipp", "\\.ixx", "\\.inl", ],

'documentation_files' => [ "README", "readme", "\\.doc", "\\.txt", "\\.html" ],

$cppresource => [ "\\.rc", ],

);

my %cppec = ('source_files' => $cppvc{'template_files'},

);

my %cppma = ('source_files' => ['buildflags',

'managed',

'no_pch',

],

'header_files' => [ 'dependent_upon',

],

);

my $csresource = 'resx_files';

my %csvc = ('source_files' => [ "\\.cs" ],

'config_files' => [ "\\.config" ],

$csresource => [ "\\.resx", "\\.resources" ],

'aspx_files' => [ "\\.aspx" ],

'ico_files' => [ "\\.ico" ],

'documentation_files' => [ "README", "readme", "\\.doc", "\\.txt", "\\.html" ],

'embedded_resource_files' => [],

'resource_files' => [],

'page_files' => [],

'appdef_files' => [],

'splash_files' => [],

);

my %csma = ('source_files' => [ 'dependent_upon',

'subtype',

],

$csresource => [ 'dependent_upon',

'generates_source',

'subtype',

],

);

my %jvc = ('source_files' => [ "\\.java" ],

'documentation_files' => [ "README", "readme", "\\.doc", "\\.txt", "\\.html" ],

);

my $vbresource = 'resx_files';

my %vbvc = ('source_files' => [ "\\.vb" ],

'config_files' => [ "\\.config" ],

$vbresource => [ "\\.resx" ],

'aspx_files' => [ "\\.aspx" ],

'ico_files' => [ "\\.ico" ],

'documentation_files' => [ "README", "readme", "\\.doc", "\\.txt", "\\.html" ],

);

my %vbma = ('source_files' => [ 'subtype' ],

);

my %language = (Creator::cplusplus() => [ \%cppvc, \%cppec, \%cppma, 'main',

1, $cppresource ],

Creator::csharp() => [ \%csvc, {}, \%csma, 'Main', 0,

$csresource ],

Creator::java() => [ \%jvc, {}, {}, 'main', 0 ],

Creator::vb() => [ \%vbvc, {}, \%vbma, 'Main', 0,

$vbresource ],

);

my %mains;

sub new {

my($class, $global, $inc, $template, $ti, $dynamic, $static, $relative, $addtemp, $addproj, $progress, $toplevel, $baseprojs, $gfeature, $relative_f, $feature, $features, $hierarchy, $exclude, $makeco, $nmod, $applypj, $genins, $into, $language, $use_env, $expandvars, $gendot, $comments, $foreclipse, $pid) = @_;

my $self = $class->SUPER::new($global, $inc,

$template, $ti, $dynamic, $static,

$relative, $addtemp, $addproj,

$progress, $toplevel, $baseprojs,

$feature, $features,

$hierarchy, $nmod, $applypj,

$into, $language, $use_env,

$expandvars,

'project');

$self->{$self->{'type_check'}} = 0;

$self->{'feature_defined'} = 0;

$self->{'features_changed'} = undef;

$self->{'project_info'} = [];

$self->{'lib_locations'} = {};

$self->{'reading_parent'} = [];

$self->{'dll_exe_template_input'}= {};

$self->{'lib_exe_template_input'}= {};

$self->{'lib_template_input'} = {};

$self->{'dll_template_input'} = {};

$self->{'flag_overrides'} = {};

$self->{'custom_special_output'} = {};

$self->{'custom_special_depend'} = {};

$self->{'special_supplied'} = {};

$self->{'pctype'} = $self->extractType("$self");

$self->{'verbatim'} = {};

$self->{'verbatim_accessed'} = {$self->{'pctype'} => {}};

$self->{'defaulted'} = {};

$self->{'custom_types'} = {};

$self->{'parents_read'} = {};

$self->{'inheritance_tree'} = {};

$self->{'remove_files'} = {};

$self->{'expanded'} = {};

$self->{'dependency_attributes'} = {};

$self->{'gfeature_file'} = $gfeature;

$self->{'relative_file'} = $relative_f;

$self->{'feature_parser'} = $self->create_feature_parser($features,

$feature);

$self->{'sort_files'} = $self->sort_files();

$self->{'source_callback'} = undef;

$self->{'dollar_special'} = $self->dollar_special();

$self->{'generate_ins'} = $genins;

$self->{'addtemp_state'} = undef;

$self->{'command_subs'} = $self->get_command_subs();

$self->{'escape_spaces'} = $self->escape_spaces();

$self->{'current_template'} = undef;

$self->{'make_coexistence'} = $makeco;

$self->{'forcount'} = 0;

$self->add_default_matching_assignments();

$self->reset_generating_types();

$self->{'pid'} = $pid;

$self->{'llctr'} = 0; # counts the hash insertion order for mp-mpc

return $self;

}

sub is_keyword {

## Is the name passed in a known keyword for a project. This includes

## keywords mapped by Define_Custom or Modify_Custom.

my($self, $name) = @_;

return $self->{'valid_names'}->{$name};

}

sub read_global_configuration {

my $self = shift;

my $input = $self->get_global_cfg();

my $status = 1;

if (defined $input) {

## If it doesn't contain a path, search the include path

if ($input !~ /[\/\\]/) {

$input = $self->search_include_path($input);

$input = $self->get_global_cfg() if (!defined $input);

}

## Read and parse the global project file

$self->{'reading_global'} = 1;

$status = $self->parse_file($input);

$self->{'reading_global'} = 0;

}

return $status;

}

sub convert_to_template_assignment {

my($self, $name, $value, $calledfrom) = @_;

## If the value we are going to set for $name has been used as a

## scoped template variable, we need to hijack the whole assignment

## and turn it into a template variable assignment.

my $atemp = $self->get_addtemp();

foreach my $key (grep(/::$name$/, keys %$atemp)) {

$self->update_template_variable(0, $calledfrom, $key, $value);

}

}

sub create_recursive_settings {

my($self, $name, $value, $assign) = @_;

## Handle both recursive_includes and recursive_libpaths in one

## search and replace.

if ($name =~ s/^recursive_//) {

## This portion of code was lifted directly from Creator::relative()

## but modified to always expand the variables. We will turn the

## expanded values back into variables below and once they're passed

## off to the assignment processing code, they will be turned into

## relative values (if possible).

if (index($value, '$') >= 0) {

my $ovalue = $value;

my($rel, $how) = $self->get_initial_relative_values();

$value = $self->expand_variables($value, $rel, 0, undef, 1);

if ($ovalue eq $value || index($value, '$') >= 0) {

($rel, $how) = $self->get_secondary_relative_values();

$value = $self->expand_variables($value, $rel, 0, undef, 1, 1);

}

}

## Create an array out of the recursive directory list. Convert all

## of the relative or full path values back into $() values.

my @dirs = ();

my $elems = $self->create_array($value);

foreach my $elem (@$elems) {

my $dlist = $self->recursive_directory_list($elem, []);

if ($dlist eq '') {

## This directory doesn't exist, just add the original value

push(@dirs, $elem);

}

else {

## Create an array out of the directory list and add it to our

## array.

my $array = $self->create_array($dlist);

push(@dirs, @$array);

}

}

## We need to return a string, so we join it all together space

## separated.

$value = join(' ', $self->back_to_variable(\@dirs));

}

return $name, $value;

}

sub process_assignment {

my($self, $name, $value, $assign, $calledfrom) = @_;

$calledfrom = 0 if (!defined $calledfrom);

## See if the name is one of the special "recursive" settings. If so,

## fix up the value and change the name.

($name, $value) = $self->create_recursive_settings($name, $value, $assign);

if (defined $value) {

if ($name eq 'after') {

mpc_debug::chkpnt_pre_after_keyword_assignment($name, $value, $assign, $calledfrom);

## Support dependency attributes. They may or may not be used by

## the project or workspace creator implementation. They are

## stored separately from the dependencies themselves. Also, note

## that a value to be added may contain more than one element to be

## added. This function will be called for each one, so we only

## need to handle one at a time.

if ($value =~ s/(\s*([^:]+)):([^\s]+)/$1/) {

## The value may contain multiple projects. But, only one

## dependency attribute will be present at any time. So, once we

## get here, we need to remove any of the other projects from the

## front of the key string.

my $key = $2;

my $value = $3;

$key =~ s/.*\s+//;

$self->{'dependency_attributes'}->{$key} = $value;

}

## Check the after value and warn the user in the event that it

## contains a value that can not be used within a project name.

if (!$self->valid_project_name($value)) {

$self->warning("after '$value' contains an invalid project name in " .

$self->{'current_input'} . ' at line ' .

$self->get_line_number() . '.');

}

## Support the '*' mechanism as in the project name, to allow

## the user to correctly depend on another project within the same

## directory.

if (index($value, '*') >= 0) {

$value = $self->fill_type_name($value,

$self->get_default_project_name());

}

mpc_debug::chkpnt_post_after_keyword_assignment($name, $value, $assign, $calledfrom);

}

## Support the '*' mechanism for libs assignment as well.

elsif ($name eq 'libs' && index($value, '*') >= 0) {

$value = $self->fill_type_name($value, $self->get_default_project_name());

}

## If this particular project type does not consider the dollar sign

## special and the user has provided two dollarsigns as an escape, we

## will turn it into a single dollar sign.

if (!$self->{'dollar_special'} && index($value, '$$') >= 0) {

$value =~ s/\$\$/\$/g;

}

## If the assignment name is valid and requires parameter (<%...%>)

## replacement, then do so. But, only do so on actual keywords.

## User defined keywords must not have the parameters replaced in

## order for them to get the correct replacement values later on.

if (defined $validNames{$name} &&

($validNames{$name} & 0x04) == 0 && index($value, '<%') >= 0) {

$value = $self->replace_parameters($value, $self->{'command_subs'});

}

}

if ($calledfrom == 0) {

$self->convert_to_template_assignment($name, $value, $calledfrom);

}

## Call the base process_assigment() after we have modified the name and

## value.

$self->SUPER::process_assignment($name, $value, $assign);

## Support keyword mapping here only at the project level scope. The

## scoped keyword mapping is done through the parse_scoped_assignment()

## method.

if (!defined $assign || $assign == $self->get_assignment_hash()) {

my $mapped = $self->{'valid_names'}->{$name};

if (defined $mapped && UNIVERSAL::isa($mapped, 'ARRAY')) {

$self->parse_scoped_assignment($$mapped[0], 0,

$$mapped[1], $value,

$self->{'generated_exts'}->{$$mapped[0]});

}

}

}

sub process_assignment_add {

my($self, $name, $value, $assign) = @_;

## See if the name is one of the special "recursive" settings. If so,

## fix up the value and change the name.

($name, $value) = $self->create_recursive_settings($name, $value, $assign);

return $self->SUPER::process_assignment_add($name, $value, $assign);

}

sub process_assignment_sub {

my($self, $name, $value, $assign) = @_;

## See if the name is one of the special "recursive" settings. If so,

## fix up the value and change the name.

($name, $value) = $self->create_recursive_settings($name, $value, $assign);

## If the assignment name is valid and requires parameter (<%...%>)

## replacement, then do so. But, only do so on actual keywords.

## User defined keywords must not have the parameters replaced in

## order for them to get the correct replacement values later on.

if (defined $validNames{$name} &&

($validNames{$name} & 0x04) == 0 && index($value, '<%') >= 0) {

$value = $self->replace_parameters($value, $self->{'command_subs'});

}

return $self->SUPER::process_assignment_sub($name, $value, $assign);

}

sub addition_core {

my($self, $name, $value, $nval, $assign) = @_;

## If there is a previous value ($nval) and the keyword is going to be

## evaled, we need to separate the values with a command separator.

## This has to be done at the MPC level because it isn't always

## possible for the user to know if a value has already been added to

## the keyword (prebuild, postbuild and postclean).

if (defined $nval &&

defined $validNames{$name} && ($validNames{$name} & 4)) {

if ($self->preserve_assignment_order($name)) {

$value = '<%cmdsep%> ' . $value;

}

else {

$value .= '<%cmdsep%>';

}

}

## For an addition, we need to see if it is a project keyword being

## used within a 'specific' section. If it is, we may need to update

## scoped settings for that variable (which are in essence template

## variables).

$self->convert_to_template_assignment($name, $value, 1);

## Next, we just give everything to the base class method.

$self->SUPER::addition_core($name, $value, $nval, $assign);

}

sub subtraction_core {

my($self, $name, $value, $nval, $assign) = @_;

## For a subtraction, we need to see if it is a project keyword being

## used within a 'specific' section. If it is, we may need to update

## scoped settings for that variable (which are in essence template

## variables).

$self->convert_to_template_assignment($name, $value, -1);

## Next, we just give everything to the base class method.

$self->SUPER::subtraction_core($name, $value, $nval, $assign);

}

sub get_assignment_for_modification {

my($self, $name, $assign, $subtraction) = @_;

## If we weren't passed an assignment hash, then we need to

## look one up that may possibly correctly deal with keyword mappings

if (!defined $assign) {

my $mapped = $self->{'valid_names'}->{$name};

if (defined $mapped && UNIVERSAL::isa($mapped, 'ARRAY')) {

$name = $$mapped[1];

$assign = $self->{'generated_exts'}->{$$mapped[0]};

}

}

## Get the assignment value

my $value = $self->get_assignment($name, $assign);

## If we are involved in a subtraction, we get back a value and

## it's a scoped or mapped assignment, then we need to possibly

## expand any template variables. Otherwise, the subtractions

## may not work correctly.

if ($subtraction && defined $value && defined $assign) {

$value = $self->relative($value, 1);

}

return $value;

}

sub begin_project {

my($self, $parents) = @_;

my $status = 1;

my $error;

## Deal with the inheritance hierarchy first

## Add in the base projects from the command line

if (!$self->{'reading_global'} &&

!defined $self->{'reading_parent'}->[0]) {

my $baseprojs = $self->get_baseprojs();

if (defined $parents) {

StringProcessor::merge($parents, $baseprojs);

}

else {

$parents = $baseprojs;

}

}

if (defined $parents) {

foreach my $parent (@$parents) {

## Read in the parent onto ourself

my $file = $self->search_include_path(

"$parent.$BaseClassExtension");

if (!defined $file) {

$file = $self->search_include_path(

"$parent.$ProjectCreatorExtension");

}

if (defined $file) {

if (defined $self->{'reading_parent'}->[0]) {

if (StringProcessor::fgrep($file, $self->{'reading_parent'})) {

$status = 0;

$error = 'Cyclic inheritance detected: ' . $parent;

}

}

if ($status) {

if (!defined $self->{'parents_read'}->{$file}) {

$self->{'parents_read'}->{$file} = 1;

## Push the base project file onto the parent stack

push(@{$self->{'reading_parent'}}, $file);

## Collect up some information about the inheritance tree

my $tree = $self->{'current_input'};

if (!defined $self->{'inheritance_tree'}->{$tree}) {

$self->{'inheritance_tree'}->{$tree} = {};

}

my $hash = $self->{'inheritance_tree'}->{$tree};

foreach my $p (@{$self->{'reading_parent'}}) {

$$hash{$p} = {} if (!defined $$hash{$p});

$hash = $$hash{$p};

}

## Begin reading the parent

mpc_debug::chkpnt_pre_parse_base_project($file);

$status = $self->parse_file($file);

mpc_debug::chkpnt_post_parse_base_project($file, $status);

## Take the base project file off of the parent stack

pop(@{$self->{'reading_parent'}});

$error = "Invalid parent: $parent" if (!$status);

}

else {

## The base project has already been read. So, if

## we are reading the original project (not a parent base

## project), then the current base project is redundant.

if (!defined $self->{'reading_parent'}->[0]) {

$file =~ s/\.[^\.]+$//;

$self->information('Inheriting from \'' .

$self->mpc_basename($file) .

'\' in ' . $self->{'current_input'} .

' is redundant at line ' .

$self->get_line_number() . '.');

}

}

}

}

else {

$status = 0;

$error = "Unable to locate parent: $parent";

}

}

}

## Copy each value from global_assign into assign

if (!$self->{'reading_global'}) {

foreach my $key (keys %{$self->{'global_assign'}}) {

if (!defined $self->{'assign'}->{$key}) {

$self->{'assign'}->{$key} = $self->{'global_assign'}->{$key};

}

}

}

return $status, $error;

}

sub get_process_project_type {

my($self, $types) = @_;

my $type = '';

my $defcomp = $self->get_default_component_name();

foreach my $t (split(/\s*,\s*/, $types)) {

my $not = ($t =~ s/^!\s*//);

if ($not) {

if ($t eq $self->{'pctype'}) {

$type = '';

last;

}

else {

$type = $self->{'pctype'};

}

}

elsif ($t eq $self->{'pctype'} || $t eq $defcomp) {

$type = $t;

last;

}

}

return $type;

}

sub matches_specific_scope {

my($self, $elements) = @_;

## First check for properties that correspond to the current project

## type. Elements that begin with "prop:" indicate a property.

my $list = '';

my $props = $self->get_properties();

foreach my $prop (split(/\s*,\s*/, $elements)) {

my $not = ($prop =~ s/^!\s*//);

if ($prop =~/(.+):(.+)/) {

if ($1 eq 'prop') {

$prop = $2;

if ($not) {

return $self->{'pctype'} if (!$$props{$prop});

}

else {

return $self->{'pctype'} if ($$props{$prop});

}

}

else {

$self->warning("$prop is not recognized.");

}

}

else {

$list .= ($not ? '!' : '') . $prop . ',';

}

}

## If none of the elements match a property, then check the type

## against the current project type or the default component name

## (which is what it would be set to if a specific clause is used with

## out parenthesis).

my $type = $self->get_process_project_type($list);

return $self->{'pctype'} if ($type eq $self->{'pctype'} ||

$type eq $self->get_default_component_name());

## Nothing matched

return undef;

}

sub parse_line {

my($self, $ih, $line) = @_;

my($status,

$errorString,

@values) = $self->parse_known($line, $ih);

## parse_known() passes back an array of values

## that make up the contents of the line parsed.

## The array can have 0 to 4 items. The first,

## if defined, is always an identifier of some

## sort.

if ($status && defined $values[0]) {

if ($values[0] eq $self->{'grammar_type'}) {

my $name = $values[1];

my $typecheck = $self->{'type_check'};

if (defined $name && $name eq '}') {

## Project Ending

if (!defined $self->{'reading_parent'}->[0] &&

!$self->{'reading_global'}) {

## Call into the project type's pre-generation hook.

$self->pre_generation();

## Fill in all the default values

$self->generate_defaults();

## Perform any additions, subtractions

## or overrides for the project values.

my $addproj = $self->get_addproj();

foreach my $ap (keys %$addproj) {

if (defined $self->{'valid_names'}->{$ap}) {

foreach my $val (@{$$addproj{$ap}}) {

if ($$val[0] > 0) {

$self->process_assignment_add($ap, $$val[1]);

}

elsif ($$val[0] < 0) {

$self->process_assignment_sub($ap, $$val[1]);

}

else {

$self->process_assignment($ap, $$val[1]);

}

}

}

else {

$errorString = 'Invalid ' .

"assignment modification name: $ap";

$status = 0;

}

}

if ($status) {

## Generate default target names after all source files are added

## and after we've added in all of the options from the

## command line. If the user set exename on the command line

## and no "main" is found, sharedname will be set too and

## most templates do not handle that well.

$self->generate_default_target_names();

## End of project; Write out the file.

($status, $errorString) = $self->write_project();

## write_project() can return 0 for error, 1 for project

## was written and 2 for project was skipped

if ($status == 1) {

## Save the library name and location

foreach my $name ('sharedname', 'staticname') {

my $val = $self->get_assignment($name);

if (defined $val) {

my $cwd = $self->getcwd();

my $start = $self->getstartdir();

my $amount = 0;

if ($cwd eq $start) {

$amount = length($start);

}

elsif (index($cwd, $start) == 0) {

$amount = length($start) + 1;

}

if ($self->{'pid'} eq 'child') {

$self->{'lib_locations'}->{$val} =

++$self->{'llctr'} . '|' .

substr($cwd, $amount);

}

else {

$self->{'lib_locations'}->{$val} =

substr($cwd, $amount);

}

last;

}

}

## Check for unused verbatim markers

foreach my $key (keys %{$self->{'verbatim'}}) {

if (defined $self->{'verbatim_accessed'}->{$key}) {

foreach my $ikey (keys %{$self->{'verbatim'}->{$key}}) {

if (!defined $self->{'verbatim_accessed'}->{$key}->{$ikey}) {

$self->warning("Marker $ikey does not exist.");

}

}

}

}

}

## Reset all of the project specific data. I am explicitly

## not resetting dependency_attributes. It is necessary that

## this information stay for the life of the ProjectCreator

## object so that the WorkspaceCreator can have access to the

## information.

foreach my $key (keys %{$self->{'valid_components'}}) {

delete $self->{$key};

delete $self->{'defaulted'}->{$key};

}

if (defined $self->{'addtemp_state'}) {

$self->restore_state($self->{'addtemp_state'}, 'addtemp');

$self->{'addtemp_state'} = undef;

}

$self->{'assign'} = {};

$self->{'verbatim'} = {};

$self->{'verbatim_accessed'} = {$self->{'pctype'} => {}};

$self->{'special_supplied'} = {};

$self->{'flag_overrides'} = {};

$self->{'parents_read'} = {};

$self->{'inheritance_tree'} = {};

$self->{'remove_files'} = {};

$self->{'custom_special_output'} = {};

$self->{'custom_special_depend'} = {};

$self->{'expanded'} = {};

$self->reset_generating_types();

}

}

$self->{$typecheck} = 0;

}

else {

## Project Beginning

($status, $errorString) = $self->begin_project($values[2]);

## Set up the default project name

if ($status) {

if (defined $name) {

if ($self->valid_project_name($name)) {

## We should only set the project name if we are not

## reading in a parent project.

if (!defined $self->{'reading_parent'}->[0]) {

$name =~ s/^\(\s*//;

$name =~ s/\s*\)$//;

$name = $self->transform_file_name($name);

## Replace any *'s with the default name

if (index($name, '*') >= 0) {

$name = $self->fill_type_name(

$name,

$self->get_default_project_name());

}

$self->set_project_name($name);

}

else {

$self->warning("Ignoring project name " .

"$name in a base project.");

}

}

else {

$status = 0;

$errorString = 'Projects can not have the following in ' .

'the name: / \\ = ? : & " < > | # %';

}

}

}

## Signify that we have a valid project

$self->{$typecheck} = 1 if ($status);

}

}

elsif ($values[0] eq '0') {

## $values[1] = name; $values[2] = value

if (defined $self->{'valid_names'}->{$values[1]}) {

$self->process_assignment($values[1], $values[2]);

}

else {

$errorString = "Invalid assignment name: '$values[1]'";

$status = 0;

}

}