|
This page introduces the programs that the Adaptive Web
Framework (AWF) develops and uses to deploy Rob's Strategy
Studio (RSS).
The programs are structured to obey complex adaptive system
(CAS) principles. That allows AWF to experiment and
examine the effects.
A production program
generates the web pages.
A testing system tests the production program. It uses a framework to support
the test programs. This is AWF's agent programming
framework as described in the agent-based
programming presentation.
An example of the other AWF agent-based programs that are also
described in the frame is the virtual robot.
Finally a strength,
weaknesses, opportunities and threats assessment is
presented.
Perl frame |
This page describes the Adaptive Web framework (AWF) test system
and the agent programming framework (Smiley) that supports its
operation.
Example test system statements are included.
To begin a test a test statement is loaded into Smiley while
Smiley executes on the Perl
interpreter.
Part of Smiley's Perl code focused on setting up the
infrastructure is included bellow.
The setup includes:
- Loading the 'Meta file'
specification,
- Initializing the Slipnet,
and Workspaces and loading them
- So that the Coderack
can be called.
The Coderack, which is the focus of a separate
page of the Perl frame then schedules and runs the codelets
that are invoked by the test statement structures.
Test framework |
This page introduces the many ways a complex modeling and coordination activity can
be implemented using agent-based
programming (see presentation).
It describes how salient
schematic alternative strings can be used to model a
situation and make a decision under evolved control.
It also introduces bottom
up model codelets and complex techniques that are covered
more fully on other pages.
Constraints on the modeling process including requirements for timeliness, parallelism, synchronization
and emergence of new models are discussed.
Once a schematic sequence is selected by a
group codelet or any additional type of modeling codelet
the codelet will initiate an iterative cycle of detect, signal,
match, deploy. This allows the actions of a schematically
selected sequence of model codelets to aggregate into a focused
agent.
A series of example signals sent by complex modeling codelets
along with their associated operons
and subgroup schematic sequences are included. The
signals are sent by the:
- merge streams spdca
builder - The initiator of merge streams's pdca cycle (see schematic pdca).
- merge streams dcycip
builder - The initiator of the planning phase of the
merge streams's pdca cycle.
- merge streams cassert
builder - The initiator of the mergestreams's case resolved assert true
conditional cascade. It is a structurally
enhanced codelet which activates at the end of the
'do' phase and signals the nucleus.
- merge streams indsloc
builder - The start locator codelet finds the
application schemata's start operon
- merge streams shsloc
builder - A start locator codelet that finds an
alternative start operon in the application schematic operon
- merge streams rchpair
builder - A receptor
that detects and relays an application signal
- pdca ecycdop
builder - A cyclin
simulation codelet which signals entry to the 'do' phase of
the pdca.
- pdca acycchp
builder - A cyclin simulation codelet which signals
entry to the 'check' phase of the pdca.
- pdca bcycacp
builder - A cyclin simulation codelet which signals
entry to the 'act' phase of the pdca.
And the Slipnet configuration which
activates the schematic subgroup sequence <mergestreams>
<for> <case> <resolved> <assert>
<true> is included.
Schematic modeling |
This page looks at how Smiley
processes the statement, such as a test request, to ensure that
each part of the statement is composed of groups.
Smiley does this through the operation of a part codelet which indirectly
sponsors the modeling of the parts of the statement.
The modeling itself is performed by model codelets.
The part codelet synchronizes
with the completion of the modeling.
The part evaluator's signal along with the associated operons and subgroup
schematic sequences are included.
The group models' Slipnet associations are included.
The codelets and supporting functions are
included.
Schematic whole part |
This page looks at how Smiley
processes the statement, such as a test request, to ensure that
each part of the statement is valid.
Smiley does this through the operation of a part codelet which indirectly
sponsors the modeling of the parts of the statement.
The modeling itself is performed by model codelets.
The part codelet synchronizes
with the completion of the modeling.
The part evaluator's signal along with the associated operons and subgroup
schematic sequences are included.
The group models' Slipnet associations are included.
The codelets and supporting functions are
included.
Part validity |
This page looks at how Smiley
processes the statement, such as a test request, to ensure that
each part of the statement is constrained.
Smiley does this through the operation of a part codelet which indirectly
sponsors the modeling of the parts of the statement.
The modeling itself is performed by
model codelets.
The part codelet synchronizes
with the completion of the modeling.
The part evaluator's signal along with the associated operons and subgroup schematic sequences are included.
The group models' Slipnet
associations are
included.
The codelets
and supporting functions are included.
Part constraints |
This page looks at how Smiley
processes the statement, such as a test request, to ensure that
each part of the statement is integral.
Smiley does this through the operation of a part codelet which
initiates a program
to assess the integrity of the parts.
The modeling itself is performed by
model codelets.
The group models' Slipnet
associations are included.
The codelets
and supporting functions are included.
Part integrity |
This page looks at how Smiley
processes the statement, such as a test request, to ensure that
the statement contains all required parts.
Smiley does this through the operation of a statement codelet
which indirectly
sponsors the modeling of the whole statement.
The modeling itself is performed by
model codelets.
The group models' Slipnet
associations are included.
The codelets
and supporting functions are included.
Syntactically whole statement |
This page looks at Smiley's
statement codelet.
What the codelet's goals are.
The three aspects
of its operations are described.
The indirect nature of its support for the
applications programs and Shewhart cycles are
illustrated.
It describes how the application codelets are inhibited from action
until the Statement codelet concludes the application's assertion or implementation
statement is viable. An application assertion statement is
described and the schematic string included.
The statement codelet Perl
and its support infrastructure are included.
Statement operation |
This page describes the need for stated assumptions to support
the setup and development
of a Smiley agent-based
application.
As an example it discusses the use of
assumptions about connecting external files to the agents.
The Smiley codelets
which process files and integrate them with the application
agents using assumptions are introduced.
The Slipnet associations relating
the Workspace schematic strings to group completion scheduled codelets are included.
The codelets
and supporting functions are included.
Schematic assumptions |
This page discusses how Smiley can
support the start of the development
phase of an agent-based application.
Startup is an artificial operation not found in living
systems. But Smiley must do it and so we discuss an
example of starting
the development phase.
With the Smiley infrastructure and the application integrated
the application's development
phase is reviewed.
The association of structural Workspaces
for state representation is
discussed.
The aggregation of
schematic associations of codelets
defines a development
agent. At the application level it processes the
application's schematic strings.
The schematic nature of the data processed by the test
application suggests the use of an indirect integration
framework. This supports the binding of codelets to
the schematic data and detecting and responding to the control
operons.
An application
polymerase complex emerges.
The codelets and supporting functions are
included.
Schematic development |
This page describes the specialized codelets that provide
life-cycle and checkpoint capabilities for Smiley applications.
The codelets implement
a Shewhart cycle.
The structural schematic nature of the cycle is described.
Transcription factor
codelets operate the phase change controls.
How inhibitory agents are integrated into the cycle is described.
An application agent with management
and operational roles emerges.
The codelets and supporting functions are
included.
Schematic PDCA |
This page describes a schematic system about abstracted 'animal'
and 'plant' cells competing in a small
world.
The schematic cell was designed to
focus in on the nature of mutation
and the adjacent possible.
THE IMPLEMENTATION IS INCOMPLETE AND ONGOING.
The codelets and infrastructure are
included.
Schematic cell |
This page describes a schematic system about abstracted neurons operating in a
circuit.
The neuronal
system was designed to focus in on the cellular nature of
a schematically defined neuron.
The goals include:
- Development of a system of cells, their differentiation
and deployment into a neuron network.
- Abstract receptor operation must support interactions of a
network of neurons and attached cells.
THE IMPLEMENTATION IS INCOMPLETE AND ONGOING.
The codelets and infrastructure are
included.
Schematic innate neuron |
This page discusses a complex adaptive system (CAS) implementation of a genetic algorithm (GA), Melanie
Mitchell's robot-janitor built as a set of Copycat codelets
integrated using agent-based
programming. The improvement in the operation of the
robots over succeeding generations of applying the GA is graphed.
The CAS that generated, and operated the robot is reviewed,
including the implementation
details and codelet operational
program flow, and the challenges and limitations of this
implementation.
The schematic strings which make up
the robot's genotype, as
well as the signals which are sent
to the nucleus of the
robot's agents so
that the agents can deploy the appropriate response strings
(which activate codelets) are listed. The Slipnet configuration required by the
system to associate the schematic strings with programmatic
forces (codelets) is also listed.
The codelets and supporting perl are also listed.
In the conclusion the
limitations of the robot-janitor abstraction in studying emergence and creative evolution are discussed and
alternative experimental frameworks are proposed. One
such, the schematic cell is the subject of a separate page in this web frame.
Virtual robot |
This page discusses how a Smiley
based application the event processor test program's operational
phase is structured.
The goals of the event processor test application are described.
The implementation strategy is outlined.
Synchronization of Smiley setup completion and operation phase
initiation is discussed.
The association of structural Workspaces
for state representation is discussed.
An application specific codelet merge streams assert
responds to the nature of the assertion. It does
not have an emergent structure. Instead it reflects software
engineering practice. It includes:
- Merge stream case specific
- Modeling with sub-programs
- Resolving of
case
- Non case assertion
The operation is setup,
inhibited, initiated, and managed by iterative
phase check-pointing provided by Smiley codelets.
Schematic
synchronization of parallel codelet cascades is performed
structurally.
The assert merge operon cascade is included.
The Slipnet concept network for
merge streams is included.
The codelets and supporting functions are
included.
Schematic assert merge |
This page describes the inhibitor
framework provided by the adaptive web framework's (AWF) Smiley agent programming
infrastructure.
Two mechanisms are provided:
- Uncompetitive inhibition of group completion.
- Uncompetitive inhibition of transcription factors.
In both cases the inhibitors provide a restriction
process.
The Slipnet inhibitor descriptions
are included.
The codelets
and supporting infrastructure are included.
Codelet restriction |
This page discusses how the adaptive web framework (AWF) Smiley supports agent-based
application's leverage of infrastucture
amplification.
A number of Smiley's amplification strategies are reviewed:
- Locality
- Enzyme
like catalysis
- Efficient
routing through the Slipnet
- Independence and
equivalence of transactional
codelets
- Structurally
enhanced state based amplification
The architecture of Smiley's grab amplification is discussed.
This includes:
- Sub program
grab amplification
- Deployment
infrastructure cooperation in grab amplification
- Generalizing
the grab architecture
The mechanisms Smiley uses to limit the impact of amplification,
such as crowding out
and processor
starvation, on other codelets operations are
discussed.
The codelets and infrastructure are included.
Infrastructure amplifier |
This page describes the 'merge streams'
application's codelet implementation of a 'case' architecture based on
the adaptive web framework's (AWF) Smiley
histone
infrastructure.
The application scenario for processing case statements is described.
It involves a schematic
binder complex for resolving the case statements.
A case tagged
application schemata.
The Smiley infrastructure that supports the case architecture is
reviewed.
The Workspace schematic strings that implement the operon supporting histone
like case control are included.
The Slipnet concept network for the
'merge streams' application's
histone like case control is included.
The codelets and supporting functions are
included.
Schematic case |
This page describes the adaptive web framework (AWF) Smiley agent progamming
infrastructure's codelet
based Copycat grouping operation.
The requirements needed for a group to complete are described.
The association of group completion with a Slipnet defined operon is described.
Either actions or signals result from the association.
How a generated signal is transported to the nucleus of the cell and
matched with an operon is
described.
A match with an operon can result
in deployment of a schematic
string to the original Workspace.
But eventually the deployed string will be destroyed.
Smiley infrastructure amplification of the group completion
operation is introduced.
This includes facilities to inhibit crowding out of
offspring.
A test file awfart04 is included.
The group codelet and supporting functions
are included.
Group complete |
This page describes the Smiley
infrastructure and codelets
that instantiate the epiphenomena
defined in the Meta file
and Slipnet.
Infrastructure sensors are introduced.
The role of phenomena in shaping the environment is discussed.
The focusing of forces by phenomena in Smiley is discussed.
The Meta file association of case
keywords with phenomena is included.
The codelets and supporting functions are included.
Phenomena |
This page describes the Copycat
Slipnet.
The goal of the Slipnet is reviewed.
Smiley's specialized use of the Slipnet is introduced.
The initial Slipnet network used by the 'Merge
Streams' and 'Virtual Robot' agent-based applications is setup in
initchemistry and is included.
The Slipnet infrastructure and initialization functions are
included.
Slipnet |
Workspace |
This page describes the Copycat
Coderack.
The details of the codelet architecture are described.
The specialized use of the Coderack by the adaptive web
framework's (AWF) Smiley is discussed.
The codelet scheduling mechanism is discussed.
A variety of Smiley extensions to the Coderack are reviewed.
The Coderack infrastructure functions are
included.
Coderack |
This page discusses how Smiley
provides signalling to its agent-based applications.
Alternative strategies for initiating the signalling are reviewed.
The codelets and supporting functions are
included.
Schematic signals |
This page discusses how Smiley
provides deployment guarantees to its agent-based
applications.
Smiley's transaction
services are reviewed.
The complex interactions of codelets
participating in a deployment cascade are discussed
including:
- The implementation of schematic switches.
- The cooperative use of goal
suppression.
- Evaluator codelets promotion
of other siblings.
Challenges of initiation of a cascade are discussed.
Tools to associate transaction protection to an operon deployed
codelet are described.
Special support for sub-program codelets is described. Completion
of transactional sub-programs presents special
challenges.
Priority and synchronization support includes:
- Delaying the
operaton of the cascade sponsor.
- Delaying
the notgcompleting
cascade participant.
- Waiting for completion of
parallel operations with the wait and relay
service.
The need to sustain resource pools is reviewed.
The use of signals to coordinate
siblings is described.
The structural binding operon
for the wait and relay service is included.
The codelets and supporting functions are
included.
Schematic cascades |
This page describes the Smiley
infrastructure that supports the associative binding of schematic strings to codelets
defined in the Meta file
and Slipnet.
The infrastructure supporting the associations is introduced.
The role of Jeff Hawkins neocortical attributes is discussed.
Relevant Slipnet configurations are
included.
The codelets and supporting functions are included.
Associative labels |
This page describes the Smiley data
structures.
Key structures are described each of which is based on a list
structure represented with an array and add and free
subroutines.
Data structures |
|
|
Perceptual infrastructure for Copycat
Summary
This page describes the This page discusses the interdependence of perception and
representation in a complex adaptive system (CAS). Hofstadter
and Mitchell's research with Copycat is
reviewed.
Copycat
Workspace.
The specialized use of the Workspace by the adaptive web
framework's (AWF) Smiley is discussed.
How text and XML are imported into the Smiley Workspace is described.
Telomeric aging of schematic structures is introduced.
The internal data structure used to represent the state of each
workspace object is included.
The Workspace infrastructure functions are
included.
Introduction
Smiley, an This page describes the Adaptive Web framework (AWF) test system
and the agent programming framework (Smiley) that supports its
operation.
Example test system statements are included.
To begin a test a test statement is loaded into Smiley while
Smiley executes on the Perl
interpreter.
Part of Smiley's Perl code focused on setting up the
infrastructure is included bellow.
The setup includes:
- Loading the 'Meta file'
specification,
- Initializing the Slipnet,
and Workspaces and loading them
- So that the Coderack
can be called.
The Coderack, which is the focus of a separate
page of the Perl frame then schedules and runs the codelets
that are invoked by the test statement structures.
agent programming framework,
needs a mechanism to define and adapt its physical
environment. To do this we 'repurposed' Copycat's solution
the Workspace.
Copycat, Douglas
Hofstadter & Melanie Mitchell's implementation of a This page discusses the interdependence of perception and
representation in a complex adaptive system (CAS). Hofstadter
and Mitchell's research with Copycat is
reviewed.
perception & representation
architecture, integrates a conceptual model with its local
perceptions of its situation. The perceptual situation is
maintained in the Workspace.
Smiley's
specialized use of the Workspace
In the adaptive web framework (AWF)'s implementation of the
architecture (the AWF test
infrastructure) the Workspace is initially loaded
with a specification statement
and nuclear Plans emerge in complex adaptive
systems (CAS) to provide the
instructions that agents use to
perform actions. The component architecture and structure
of the plans is reviewed.
memes based on the This page describes the Copycat
Slipnet.
The goal of the Slipnet is reviewed.
Smiley's specialized use of the Slipnet is introduced.
The initial Slipnet network used by the 'Merge
Streams' and 'Virtual Robot' agent-based applications is setup in
initchemistry and is included.
The Slipnet infrastructure and initialization functions are
included.
Slipnet's relations and the physical
rules defined in the Meta
file is loaded by the adaptive web framework's (AWF) Smiley. It defines the application system's basic rules, its keywords and their properties and the form of the assertion or implementation statement the application uses. . The Workspace is essentially a chemical, molecules obtain chemical properties from the atoms from which they are composed and from the environment in which they exist. Being relatively small they are subject to phenomena which move them about, inducing collisions and possibly reactions with other molecules. AWF's Smiley simulates a chemical environment including associating the 'molecule' like strings with codelet based forces that allow the strings to react based on their component parts, sequence etc. The complex adaptive system (CAS)
nature of a value delivery system is first introduced. It's a network
of agents acting as relays.
The critical nature of hub agents and the difficulty of altering
an aligned network is reviewed.
The nature of and exceptional opportunities created by platforms are discussed.
Finally an example of aligning a VDS is presented.
environment into which Plans emerge in complex adaptive
systems (CAS) to provide the
instructions that agents use to
perform actions. The component architecture and structure
of the plans is reviewed.
schematic structures such as
additional memes can This page discusses the mechanisms and effects of emergence
underpinning any complex adaptive system (CAS). Key research is
reviewed.
emerge.
Each Workspace object, like a carbon atom, is a building block,
able, due to its list structure and functions (addwsoli), to integrate into backbone and
side chains. This enables the rich representation
environment where descriptions can be supported.
Text
including XML style keywords can be imported and converted
into Workspace structures
Any text string can be loaded into the Workspace using the convbws function. As it processes
each character of the text string convbws decides if it is part
of a keyword defined in the Meta file. If it is then the
keyword will be added to the Workspace rather than the discrete
characters. Similarly if convbws is told via 'meta
commands' embedded in the text string that this part of the
string is grouped then if convbws identifies the Workspace
object as being part of a sequence configured in the Slipnet the
Workspace group will be associated with this Slipnet
configuration.
Workspace objects include a keyword attribute. Using a
chemical analogy this is the 'atomic' core of the Workspace
object. Each keyword can have physical This page describes the Smiley
infrastructure and codelets
that instantiate the epiphenomena
defined in the Meta file
and Slipnet.
Infrastructure sensors are introduced.
The role of phenomena in shaping the environment is discussed.
The focusing of forces by phenomena in Smiley is discussed.
The Meta file association of case
keywords with phenomena is included.
The codelets and supporting functions are included.
phenomena associated with it.
The Workspace objects become the focus of attention of Plans are interpreted and implemented by agents. This page
discusses the properties of agents in a complex adaptive system
(CAS).
It then presents examples of agents in different CAS. The
examples include a computer program where modeling and actions
are performed by software agents. These software agents
are aggregates.
The participation of agents in flows is introduced and some
implications of this are outlined.
agents which are aggregates
of codelets
operating on execution infrastructure called the This page describes the Copycat
Coderack.
The details of the codelet architecture are described.
The specialized use of the Coderack by the adaptive web
framework's (AWF) Smiley is discussed.
The codelet scheduling mechanism is discussed.
A variety of Smiley extensions to the Coderack are reviewed.
The Coderack infrastructure functions are
included.
Coderack. Each time an agent
identifies a perception about an object or group of objects it
deploys a Workspace object This page discusses the tagging of signals
in a complex adaptive system (CAS).
Tagged signals can be used to control filtering of an event
stream. Examples of CAS filters are reviewed.
tag.
The Workspace objects various attributes are mapped to parts of a procedurally addressed bit
vector.
The percepts (tags) are descriptors
that are associated with the particular situation.
Schematic structures can become deployed in any Workspace.
Smiley
telomeric schematic structures
Telomeric seal the ends of a chromosome. During each replication of the chromosome the telomeres shrink slightly. Over time they act as an indication of the total age of the organism and contribute to the death from 'old age' of some organisms. Stem cells are protected from this chromosomal aging by telomerases. But differentiated cells are expected to die and do not express telomerase. In the adaptive web framework's (AWF) Smiley telomeric infrastructure counts down the age of telomeric schematic strings. The analogy with a real telomere is weak and has no operational equivalence! schematic
structures have the additional property that they are monitored,
aged and can be destroyed, by destruction codelets (s, e, b), once their density reaches a threshold and
their associated telomeric count drops below an ageing threshold. A
special independent and equivalent form of telomeric schemata
can represent multiple codelets, is This page describes the Smiley
infrastructure that supports the associative binding of schematic strings to codelets
defined in the Meta file
and Slipnet.
The infrastructure supporting the associations is introduced.
The role of Jeff Hawkins neocortical attributes is discussed.
Relevant Slipnet configurations are
included.
The codelets and supporting functions are included.
associated
with jhls references,
and is protected from destruction.
Workspace object state
# Keywords are chained together by their list heads; The end of the list is a sentinel
# The head of an active list entry will be the list index of the next entry in the list
# With the hash the list can be entered at one sentinel.
# The head is setup for an easy add of a new element
# memes->{wsobjectl} => wsol->{l}
# wsol-> {l} [$i][0] is backward link
# wsol-> {l} [$i][1] is forward link
# wsol-> {l} [$i][2] is index of first perception descriptor
# wsol-> {l} [$i][3] is number of descriptors
# wsol-> {l} [$i][4] is the keyword in first element
# wsol-> {l} [$i][5] is the instantaneous mean activation (5+6 = salience)
# wsol-> {l} [$i][6] is the instantaneous unhappiness
# wsol-> {l} [$i][7] is the instantaneous strength
# wsol-> {l} [$i][8] is the head log items index or 0 if none
# wsol-> {l} [$i][9] is the access count element items index or 0 if none
# wsol-> {l} [$i][10] is the log usage count: log will write if value is > 0
# wsol-> {l} [$i][11] is the wsbasetype if setup
# wsol-> {l} [$i][12] is the wsbaseind if setup
# gccache
# wsol-> {l} [$i][13] is the completed wsgroups sponsor if setup
# wsol-> {l} [$i][14] is previous logical workspace object
# wsol-> {l} [$i][15] points to the base and offset of the workspace in wsbl
# wsol-> {l} [$i][16] is the next logical workspace object
# wsol-> {l} [$i][17] is [0] the keyword backward links wsi
# wsol-> {l} [$i][18] is [1] the keyword forward links wsi
# wsol-> {l} [$i][19] is primary keyword position in metafile
# wsol-> {l} [$i][20] is primary keyword wsi
# wsol-> {l} [$i][21] is count of begins that wso is within scope
# wsol-> {l} [$i][22] is count of starts that wso is within scope
# wsolfbv
# wsol-> {l} [$i][23] is itstrengths value
# wsol-> {l} [$i][26] is link address of 'single' group descriptor (fgrpd)
# tdgroupdcache
# wsol-> {l} [$i][25] is cache value for tdgroup1
# wsol-> {l} [$i][27] is cache value for tdbond1
# wsol-> {l} [$i][28] is cache value for bugroup1
# wsol-> {l} [$i][29] is isterminated cache if present
# wsol-> {l} [$i][30] is bindtoinspector cache if present
# wsol-> {l} [$i][31] is bustatement cache if present
# wsol-> {l} [$i][32] is namespace (operon|stbinding) relative jhlsoi set in deploymd & groupbuilder when deploys completed group and matches jhlabels
# wsol-> {l} [$i][33] is histone binding ptr if present and non-zero
# wsol-> {l} [$i][34] is jhlsi for groupcomplete sponsor wso
#
# wsol-> {fbs} [$i][23 - 23] 't==2' is record of descriptor update (strength)
# wsol-> {fbs} [$i][24 - 23] 't==2' is record of descriptor update (unhappiness)
# wsol-> {fbs} [$i][25 - 23] 't==2' is record of descriptor update (tdgroup1)
# wsol-> {fbs} [$i][27 - 23] 't==2' is record of descriptor update (tdbond1:strocc)
# wsol-> {fbs} [$i][28 - 23] 't==2' is record of descriptor update (bugroup1)
#
#
#
Functions#
sub convbws {
my($myli, $buffer, $kwp, $kwpr, $kwmi, $kwmir, $sponsor, $insymbol, $inmsymbol, $started, $end, $depstag, $depttag, $dephtag, $wsi, $namespace, $strscope, $actbt, $setwsclinv)=@_;
my ($char, $schar, $kws, $kwl, $kwind, $kwai, $ptstoptf, $ptstarttf, $ptrecordtf, $linki, $cwsbi, $akwai, $ptmrf, $ptmbf, $ptmgf, $ptmhf, $ptmtf, $ptwindtf, $ptunwindtf, $newmemetics, $removekwcc, $wascomp, $wascbp, $wascsp,
$sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdat, $convst, $convet, $convwst, $convwet, $convcst, $convcet, $convcbst, $convcbet, $convost, $convoet);
# characterise each character, or token in a buffer and make a wso
#
# updated for merged workspaces
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("convbws kwp $$kwp kwpr $kwpr kwmi $kwmi kwmir $kwmir wsi $wsi ");
}
if ($Awfif::memes-> {trace} == $Awfif::memes-> {tracehrtime}) {
use Time::HiRes 'time';
($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdat) = localtime(time);
};
$convst = time ();
$cwsbi = $Awfif::memes-> {currentwsbi};
# convflip
# while ( $$buffer =~/<(\/)*(rhl)+(t)*(case)*([^>]+)?>+?/i) {
while ( $$buffer =~/<(\/|#)*(rhl)+(t)*(case)*([^>]+)?>+?/i) {
my ($a, $b);
$a = $1.$2.$3.$4.$5;
$b = $1.$5.$2.$3.$4;
$$buffer =~ s/\Q<$a/<$b/;
} # flip complete
$convcet = time ();
$Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convfsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convfsum}] + $convcet - $convst;
$char = unpack ('a', $$buffer); #prime char
$removekwcc = '';
if (!$$setwsclinv) {
&wsclinv (0, $wsi, $strscope);# force the bottom-up workspace caches to reset
$$setwsclinv = 't';
};#
$Awfif::memes-> {cativationchange} [$wsi] = 't';
while ($char ne '') {#not end of record
if ($Awfif::memes-> {comprocessing} == 1) {#remember if comprocessing so can clear the char if stop
if ($Awfif::memes-> {cbprocessing} == 1) {#remember if cbprocessing so can record the stop
if ($Awfif::memes-> {csprocessing} == 1) {#remember if catch string processing so can record the stop
# work in the new workspace
$Awfif::memes-> {currentwsbi} = $wsi;
if (($char eq '<')
&& ( keywmatch ($myli, \$$buffer, \$kws, \$kwind, \$kwl, $kwmi, $kwmir, \$Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], $Awfif::wsbl-> {wsot} [$Awfif::memes-> {currentwsbi}], \$kwai, $wsi, \@$started, \$$end, \$newmemetics, \$Awfif::memes-> {comprocessing}, \$Awfif::memes-> {cbprocessing}, \$Awfif::memes-> {csprocessing}))) {#its a keyword token
$convcst = time ();
$removekwcc = 't';
$$buffer =~ s/\Q$kws//i;
# convbwscb
if ($Awfif::memes-> {cbprocessing} == 1) {#special processing on anything except </rhlbmsge>
$$buffer =~ s/\Q>//i;
$char = '(';
&newwso ($myli, \$char, 1, $Awfif::memes->{snnh}{ichar}, \$Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], $Awfif::wsbl-> {wsot} [$Awfif::memes-> {currentwsbi}]);# make it into a char based wso
# describe the fact that this paren really substitutes for a meta tag
$Awfif::wsol-> {l} [awsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}])][2]
= setupdesc ( $Awfif::memes-> {snnh} {start},
($Awfif::memes-> {snnh} {mcharbuffer}), #its an end edge
$Awfif::memes-> {snnh} {mattrib},
$Awfif::wsol-> {l} [awsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}])][2],
awsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}]));
$char = '';
}#if
elsif ($Awfif::memes-> {csprocessing} == 1) {#special processing on anything except </tmbinding>
if ($$buffer =~ /(\s)*(['"])+(\s)*(\w+)*(\s)*(['"])+(\s)*/i){
$Awfif::memes-> {catchstring} [ ++ $Awfif::memes-> {catchstring} [0] ] = $4;
$$buffer =~ s/\Q$1$2$3$4$5$6$7//i;
# $Awfif::memes-> {csprocessing} = 0;#so that deploymd processes the end keyword
# convbwscoms
elsif ($Awfif::memes-> {comprocessing} == 0) {# otherwise stop processing anything except </comm
no strict 'refs';
if (@$inmsymbol != 0) {
my (@dumstarted, $dumend);
$dumstarted[0] = -1;
$dumstarted[1] = '';#initial phase
$dumend = 0;
&deploymd ($myli, \@$inmsymbol, $wsi, 0, \@dumstarted, \$dumend, \$$depstag, \$$depttag, \$$dephtag, $newmemetics, $namespace, $strscope, $actbt);
};#deploy start edge if appropriate
&newwso ($myli, \$kws, $kwl, $kwind, \$Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], $Awfif::wsbl-> {wsot} [$Awfif::memes-> {currentwsbi}]);# make it into a char based wso
no strict 'refs';
if (@$inmsymbol != 0) {
&deploymd ($myli, \@$inmsymbol, $wsi, $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], \@$started, \$$end, \$$depstag, \$$depttag, \$$dephtag, $newmemetics, $namespace, $strscope, $actbt);
}#deploy descriptors for meta tags
else {#clear end
if ((Awfif::wsbasetype( $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}]) > 0)
&& ((defined ($actbt)) && ($actbt)) #only activate if caller requires it
# && (($actbt ne '') && ($actbt))
&& ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[Awfif::wsbasetype( $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}])] > 0) ){#activate the base type
&setinhib (wsbasetype( $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}]),0);
&Awfif::actnodes (wsbasetype($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}]), $Awfif::memes-> {convfrom}, $strscope);
};#found basetype
};#not a new meta keyword
$akwai = flagkws ($kwai, \$ptstoptf, \$ptstarttf, \$ptrecordtf, \$ptmrf, \$ptmbf, \$ptmgf, \$ptmtf, \$ptwindtf, \$ptunwindtf, \$ptmhf);
if (
($ptmgf) &&
($ptstarttf)) {
my ($wsbi);
$wsbi = $Awfif::memes-> {currentwsbi};
$Awfif::memes-> {currentwsbi} = $wsi;
push (@$inmsymbol, $Awfif::wsol-> {l}[$akwai][4]);
$Awfif::memes-> {currentwsbi} = $wsbi;
$linki = addmkw ($sponsor);
$Awfif::mkwl-> {l} [$linki][3] = $Awfif::wsol-> {l}[$akwai][4];
$$depstag = 't';
}#memetic start
# convbwstel1
elsif (
($ptmtf) &&
($ptstarttf)) {#Telomeric memetic
push (@$inmsymbol, $Awfif::wsol-> {l}[$akwai][4]);
$linki = addmkw ($sponsor);
$Awfif::mkwl-> {l} [$linki][3] = $Awfif::wsol-> {l}[$akwai][4];
$$depttag = -1;
}#telomeric memetic start
# convbwshis1
elsif (
($ptmhf) &&
($ptstarttf)) {#histome memetic
push (@$inmsymbol, $Awfif::wsol-> {l}[$akwai][4]);
$linki = addmkw ($sponsor);
$Awfif::mkwl-> {l} [$linki][3] = $Awfif::wsol-> {l}[$akwai][4];
$$dephtag = -(addhistone ($sponsor));
}#histome memetic start
elsif (
# ($ptrecordtf) &&
$$insymbol = 't';
$linki = addkw ($sponsor);
$Awfif::kwl-> {l} [$linki][3] = $Awfif::wsol-> {l}[$akwai][4];
if ($ptwindtf) {# need to mark the head of the kwl
$Awfif::kwl-> {w} [$Awfif::kwl-> {h}] = 't';
};#if wind
}
elsif (
# ($ptrecordtf) &&
my ($kw, $scomp);
$kw = $Awfif::wsol-> {l}[$akwai][4];
$kw =~ s/\Q\///i;
$scomp = '';
# convbwstel2
# convbwshis2
if (($ptmbf) or ($ptmgf) or ($ptmrf) or ($ptmtf) or ($ptmhf)) {#memetic
$linki = $Awfif::mkwl-> {h};
}
else {
$linki = $Awfif::kwl-> {h};
};
while ((!$scomp) && ($linki != 0)) {
# convbwstel3
# convbwshis3
if (($ptmbf) or ($ptmgf) or ($ptmrf) or ($ptmtf) or ($ptmhf)) {
if ($kw eq $Awfif::mkwl-> {l} [$linki][3]) {
$scomp = 't';
&freemkw ($linki);
# seems to create problems removed 1 sep 07 if ($Awfif::mkwl-> {tlistl} == $Awfif::mkwl-> {flistl}) {
pop (@$inmsymbol);
push (@$inmsymbol, $Awfif::wsol-> {l}[$akwai][4]);
if ($newmemetics) {
# convbwshis4
my (@hainmsymbol);
&deploymd ($myli, \@$inmsymbol, $wsi, $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], \@$started, \$$end, \$$depstag, \$$depttag, \$$dephtag, $newmemetics, $namespace, $strscope, $actbt);
$$end = '';
@hainmsymbol = remstkw ($myli, \@$inmsymbol);
if (@hainmsymbol != 0) {
&deploymd ($myli, \@hainmsymbol, $wsi, $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], \@$started, \$$end, \$$depstag, \$$depttag, \$$dephtag, $newmemetics, $namespace, $strscope, $actbt);
}#deploy descriptors for meta tags
};# if
# seems to create problems removed 1 sep 07 };#if
$linki = $Awfif::mkwl-> {l} [$linki] [0];
}
else {
if ($kw eq $Awfif::kwl-> {l} [$linki][3]) {
$scomp = 't';
&freekw ($linki);
if ($Awfif::kwl-> {tlistl} == $Awfif::kwl-> {flistl}) {
$linki = $Awfif::kwl-> {l} [$linki] [0];
};#non memetic
};#while entries in active list and not found match
if ($ptunwindtf) {# need to remove entries from the head of kwl until match
$linki = $Awfif::kwl-> {h};
while ($linki != 0) {
$linki = unwindkw ($linki);
};# while wind
};#if wind
};#if
# restore current default workspace base
$Awfif::memes-> {currentwsbi} = $cwsbi;
}# not in comment mode
$convcet = time ();
$Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convcsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convcsum}] + $convcet - $convcst;
}# possible keyword
elsif (($Awfif::memes-> {cbprocessing} == 1)
$convcbst = time ();
no strict 'refs';
if (@$inmsymbol != 0) {
my (@dumstarted, $dumend);
$dumstarted[0] = -1;
$dumstarted[1] = '';
$dumend = 0;
&deploymd ($myli, \@$inmsymbol, $wsi, 0, \@dumstarted, \$dumend, \$$depstag, \$$depttag, \$$dephtag, $newmemetics, $namespace, $strscope, $actbt);
}#deploy start edge if appropriate
&newwso ($myli, \$char, 1, $Awfif::memes->{snnh}{char}, \$Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], $Awfif::wsbl-> {wsblot} [$Awfif::memes-> {currentwsbi}]);# make it into a char based wso
no strict 'refs';
if (@$inmsymbol != 0) {
&deploymd ($myli, \@$inmsymbol, $wsi, $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], \@$started, \$$end, \$$depstag, \$$depttag, \$$dephtag, $newmemetics, $namespace, $strscope, $actbt);
}#deploy descriptors for meta tags
else {#clear end
if (($char ne '<')
or ($char eq unpack ('a', $$buffer))# turns out that two open chevrons does not occur often in the char buffer datastream
){
$$buffer =~ s/\Q$char//i;
};#if
$char = '';
$convcbet = time ();
$Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convcbsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convcbsum}] + $convcbet - $convcbst;
}
elsif ($Awfif::memes-> {csprocessing} == 1) {#special processing on anything except </tmbinding>
if ($$buffer =~ /(\s)*(['"])+(\s)*(\w+)*(\s)*(['"])+(\s)*/i){
$Awfif::memes-> {catchstring} [ ++ $Awfif::memes-> {catchstring} [0] ] = $4;
$$buffer =~ s/\Q$1$2$3$4$5$6$7//i;
# $Awfif::memes-> {csprocessing} = 0;
$$buffer =~ s/\Q$char//i;
};#else
$char = '';
}
elsif (($char eq '<')
&& ($wascsp)
) {#keyword has already processed the buffer
$char = '';
$wascsp = '';
}
elsif (($char eq '<')
&& ($wascomp)
) {#keyword has already processed the buffer
$char = '';
$wascomp = '';
}
elsif (($char eq '<')
&& ($Awfif::memes-> {cbprocessing} != 1)
&& ($wascbp)
) {#keyword has already processed the buffer
$char = ')';
&newwso ($myli, \$char, 1, $Awfif::memes->{snnh}{ichar}, \$Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], $Awfif::wsbl-> {wsot} [$Awfif::memes-> {currentwsbi}]);# make it into a char based wso
# describe the fact that this paren really substitutes for a meta tag
$Awfif::wsol-> {l} [awsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}])][2]
= setupdesc ( $Awfif::memes-> {snnh} {stop},
($Awfif::memes-> {snnh} {mcharbuffer}), #its an end edge
$Awfif::memes-> {snnh} {mattrib},
$Awfif::wsol-> {l} [awsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}])][2],
awsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}]));
# get rid of the closing chevron left over from the stop charbuffer keyword
$char = '>';
$$buffer =~ s/\Q$char//i;
$char = '';
$wascbp = '';
}
elsif ($char eq "\n") {
$$buffer =~ s/\Q$char//i;
}
elsif (($Awfif::memes-> {comprocessing} == 1)
) {#keyword has already processed the buffer
#old use $convcst = time ();
$$buffer =~ s/\Q$char//i;
$char = '';
#old use $convcet = time ();
#old use $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convcsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convcsum}] + $convcet - $convcst;
elsif (($char eq '>')
&& ( ($removekwcc) or ($wascomp) )
) {#keyword has already processed the buffer
$$buffer =~ s/\Q$char//i;
$char = '';
$removekwcc = '';
$wascomp = '';
}
elsif (($schar = ''.$char) ne ' ') {#hopefully force a number to be treated as a character rather than => else
$convost = time ();
if ($$insymbol) {
my ($convoast, $convoaet);
&newwso ($myli, \$char, 1, $Awfif::memes->{snnh}{char}, \$Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], $Awfif::wsbl-> {wsblot} [$Awfif::memes-> {currentwsbi}]);# make it into a char based wso
$convoast = time ();
if ((Awfif::wsbasetype ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1)) > 0)
&& ((defined ($actbt)) && ($actbt)) #only activate if caller requires it
# && (($actbt ne '') && ($actbt))
&& (Awfif::wsbasetype ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}],-1)) ==
$Awfif::workspace-> {l} [$Awfif::wsol-> {l} [ awsoadr ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}],-1))] [2]][2])
&& ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [wsbasetype ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1))] > 0) ) {#activate the base type
&Awfif::actnodes ($Awfif::workspace-> {l}[$Awfif::wsol-> {l}[ awsoadr ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1))][2]][2], $Awfif::memes-> {descato}, $strscope);
};#found basetype
$convoaet = time ();
$Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convoasum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convoasum}] + $convoaet - $convoast;
no strict 'refs';
if (@$inmsymbol != 0) {
&deploymd ($myli, \@$inmsymbol, $wsi, $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], \@$started, \$$end, \$$depstag, \$$depttag, \$$dephtag, $newmemetics, $namespace, $strscope, $actbt);
};#deploy descriptors for meta tags
}
else {
$convwst = time ();
&newwso ($myli, \$char, 1, $Awfif::memes->{snnh}{ichar}, \$Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], $Awfif::wsbl-> {wsot} [$Awfif::memes-> {currentwsbi}]);# make it into a char based wso
$convwet = time ();
$Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convwsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convwsum}] + $convwet - $convwst;
};#if
if (($char ne '<')
or (unpack ('a', $$buffer) eq '<')
) {#the keyword processor will have removed the < from the buffer even if it decides this isn't a keyword.
$$buffer =~ s/\Q$char//i;
};#if
$char = '';
# go back to current work space
$Awfif::memes-> {currentwsbi} = $cwsbi;
$convoet = time ();
$Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convosum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convosum}] + $convoet - $convost;
}# else make char
else {#its going to be classed as white space
$convwst = time ();
if ($$insymbol) {
&newwso ($myli, \$char, 1, $Awfif::memes->{snnh}{char}, \$Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], $Awfif::wsbl-> {wsot} [$Awfif::memes-> {currentwsbi}]);# make it into a char based wso
if ((Awfif::wsbasetype( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1)) > 0)
&& ((defined ($actbt)) && ($actbt)) #only activate if caller requires it
&& (Awfif::wsbasetype ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1)) ==
$Awfif::workspace-> {l} [$Awfif::wsol-> {l}[ awsoadr( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1))] [2]] [2])
&& ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [ Awfif::wsbasetype ( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1))] > 0) ){#activate the base type
&Awfif::actnodes ($Awfif::workspace-> {l}[$Awfif::wsol-> {l}[ awsoadr( trwsoadr ($Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], -1))][2]][2], $Awfif::memes-> {descato}, $strscope);
};#found basetype
no strict 'refs';
if (@$inmsymbol != 0) {
&deploymd ($myli, \@$inmsymbol, $wsi, $Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], \@$started, \$$end, \$$depstag, \$$depttag, \$$dephtag, $newmemetics, $namespace, $strscope, $actbt);
};#deploy descriptors for meta tags
}
else {
&newwso ($myli, \$char, 1, $Awfif::memes->{snnh}{whitespace}, \$Awfif::wsbl-> {wsbloh} [$Awfif::memes-> {currentwsbi}], $Awfif::wsbl-> {wsot} [$Awfif::memes-> {currentwsbi}]);# make it into a whitespace based wso
};#if
$$buffer =~ s/\Q$char//i;
# go back to current work space
$Awfif::memes-> {currentwsbi} = $cwsbi;
$convwet = time ();
$Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convwsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convwsum}] + $convwet - $convwst;
};
$char = unpack ('a', $$buffer); #prime char
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("convbws char($char) ");
};# trace
};# while to process each char in the record
$convet = time ();
$Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convbsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {convbsum}] + $convet - $convst;
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("convbwsx\n");
};# trace
} # end of convbws
#
sub flagkws {
my ($kwai, $ptstoptf, $ptstarttf, $ptrecordtf, $ptmrf, $ptmbf, $ptmgf, $ptmtf, $ptwindtf, $ptunwindtf, $ptmhf)=@_;
my ($i, $akwai, $cwsbi);
# flag the keywords matched in the workspace
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("flagkws kwai $kwai ");
}
$cwsbi = $Awfif::memes-> {currentwsbi};
$$ptstoptf = '';
$$ptstarttf = '';
$$ptrecordtf = '';
$$ptmrf = '';
$$ptmbf = '';
$$ptmgf = '';
$$ptmtf = '';
$$ptmhf = '';
$$ptunwindtf = '';
$$ptwindtf = '';
# work with the meta keyword workspace
$Awfif::memes-> {currentwsbi} = $Awfif::memes-> {kwwsbi};
$akwai = awsoadr ($kwai);
for ($i = $Awfif::wsol-> {l}[$akwai][2];$i < ($Awfif::wsol-> {l}[$akwai][2] + $Awfif::wsol-> {l}[$akwai][3]); $i++) {
if ($Awfif::memes-> {keywordl}[$i] eq 'ptstartt') {
elsif ($Awfif::memes-> {keywordl}[$i] eq 'ptstopt') {
elsif ($Awfif::memes-> {keywordl}[$i] eq 'ptrecordt') {
elsif ($Awfif::memes-> {keywordl}[$i] eq 'ptwindt') {
elsif ($Awfif::memes-> {keywordl}[$i] eq 'ptunwindt') {
if ($Awfif::memes-> {keywordl}[$i] eq 'ptmsgroupt') {
if ($Awfif::memes-> {keywordl}[$i] eq 'ptmsbondt') {
if ($Awfif::memes-> {keywordl}[$i] eq 'ptmsrelt') {
# flagkwstel
if (($Awfif::memes-> {keywordl}[$i] eq 'pttelomerestt') or ($Awfif::memes-> {keywordl}[$i] eq 'pttelomerespt')) {
# flagkwshis
if ($Awfif::memes-> {keywordl}[$i] eq 'ptmhistt' ) {
$Awfif::memes-> {currentwsbi} = $cwsbi;
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("flagkwsx ptstoptf ($$ptstoptf) ptstarttf ($$ptstarttf) ptrecordtf ($$ptrecordtf) ptmrf ($$ptmrf) ptmbf ($$ptmbf) ptmgf ($$ptmgf) ptmtf ($$ptmtf) ptwindtf ($$ptwindtf) ptunwindtf ($$ptunwindtf) ret $akwai\n");
};# trace
return $akwai
} # end of flagkws
#
#
sub addwsoli {
# setup the structures to support linked buffers
my ($pflink, $plink, $nslinkh, $aahead, $newhead, $headsentl);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
if ( ($Awfif::memes-> {chckadd})
&& (($$list-> {f} < 0)
or ($$list-> {t} <0)
or ($$list-> {f} >= $$list-> {p})
or ($$list-> {t} >= $$list-> {p})
or (($$list-> {f} != 0)
&& ($Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#
or (($$list-> {t} != 0)
&& ($Awfif::wsol-> {l}[$$list-> {t}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#
)
) {&break()};
# setup the links data
# the head and tail of this virtual workspace are managed here
# if the tail is 0 then set it to 1 and initialise the head to 1
if ($Awfif::wsbl-> {newhead}[$Awfif::memes-> {currentwsbi}]) {
$aahead = 0;
$Awfif::wsbl-> {newhead}[$Awfif::memes-> {currentwsbi}] = '';
$newhead = 't';
}
else {
$aahead = awsoadrd ($Awfif::wsbl-> {wsoh}[$Awfif::memes->{currentwsbi}]);
};
# create an active descriptor
$pflink = $$list-> {f};
if (($pflink != 0 )
&& (($newhead) or ($pflink != $Awfif::wsbl-> {l} [$Awfif::memes-> {currentwsbi}][2]) or (canrejfwso (\$pflink, \$$list)))
){
# can reclaim one from the inactive list
# The inactive list can use absolute addressing
if ($Awfif::wsol-> {l}[$pflink][ $Awfif::memes-> {wsowsi}] != 0) #*** submacrok ***#
{&break()};
$$list-> {flistl}--;
$plink = $Awfif::wsol-> {l}[$pflink][ $Awfif::memes-> {wsoprev}]; #*** submacrok ***#
if ($plink != 0) {
$Awfif::wsol-> {l}[$plink][ $Awfif::memes-> {wsonext}] = 0; #*** submacrok ***#
$$list-> {f} = $plink;
} # if
else {#zero the free head ptr
$$list-> {f} = 0;
$$list-> {t} = 0;
};
$headsentl = $Awfif::wsol-> {l}[awsoadrd ($Awfif::wsbl-> {wsoh}[$Awfif::memes-> {currentwsbi}])][ $Awfif::memes-> {wsonext}]; #*** submacrok ***#
# if this is a new head and the ws uses arch sentinals need to setup ws base and offset
if (($newhead) && ($Awfif::wsbl-> {wsas}[$Awfif::memes->{currentwsbi}])) {#create sentinals
# the base + 1 must be the real address of the first item since that is the tail
$Awfif::wsbl-> {l}[$Awfif::memes->{currentwsbi}][2] = $pflink-1;#base
$Awfif::wsbl-> {l}[$Awfif::memes->{currentwsbi}][3] = 0;#offset
$Awfif::wsbl-> {ofssum} [$Awfif::memes->{currentwsbi}] = 0;
};#setup the ws base and offset
# The control data structures can use absolute addressing still
if ((!$Awfif::wsbl-> {wsas}[$Awfif::memes-> {currentwsbi}]) or ($newhead) or ($Awfif::wsbl-> {wsss}[$Awfif::memes-> {currentwsbi}])) {# don't move the head if this is a sentinal
$Awfif::wsbl-> {wsoh}[$Awfif::memes->{currentwsbi}] = grwsoadr ($pflink);
};
# the wsol head should have a sentinal in its 16 if architected sentinals in use so must remember this rel address as we restructure this
if (!$newhead) {
$Awfif::wsol-> {l}[$aahead][ $Awfif::memes-> {wsonext}] = grwsoadr ($pflink); #*** submacrok ***#
# setup the relative environment
$Awfif::wsol-> {l}[$pflink][ $Awfif::memes-> {wsoprev}] = grwsoadr ($aahead); #*** submacrok ***#
if (($Awfif::wsbl-> {wsas}[$Awfif::memes->{currentwsbi}]) && ($Awfif::wsbl-> {wsss}[$Awfif::memes-> {currentwsbi}])) {#head sentinal needs setting up
$Awfif::wsol-> {l}[$pflink][ $Awfif::memes-> {wsonext}] = $headsentl; #*** submacrok ***#
$Awfif::wsol-> {l}[awsoadrd ($headsentl)][ $Awfif::memes-> {wsoprev}] = grwsoadr ($pflink); #*** submacrok ***# #another problem for macro dep
}
else {
$Awfif::wsol-> {l}[$pflink][ $Awfif::memes-> {wsonext}] = 0; #*** submacrok ***#
};#else
};#if
$nslinkh = $pflink;
}# found free links
else {
# if there weren't any then get a newone
# if this is a new head and the ws uses arch sentinals need to setup ws base and offset
$aahead = newwsolink ($aahead, \$$list);
$$list-> {tlistl}++;
$nslinkh = $aahead;
if ((!$Awfif::wsbl-> {wsas}[$Awfif::memes-> {currentwsbi}]) or ($newhead) or ($Awfif::wsbl-> {wsss}[$Awfif::memes-> {currentwsbi}])) {# don't move the head if this is a sentinal
# The head is really a relative index of the head of this workspace.
$Awfif::wsbl-> {wsoh}[$Awfif::memes-> {currentwsbi}] = grwsoadr ($nslinkh);
};
}; #else
# now have a descriptor but it may need sentinals (flagged by $newhead with {wsas})
if (($newhead) && ($Awfif::wsbl-> {wsas}[$Awfif::memes->{currentwsbi}])) {#create sentinals
my ($headsi, $aheadsi, $tailsi, $atailsi, $ahdptr);
# tail sentinal
$tailsi = addwsoli (\$Awfif::wsol);
$atailsi = awsoadrd ($tailsi);
# fix up the pointers
$Awfif::wsol-> {l}[$atailsi][ $Awfif::memes-> {wsowsi}] = $Awfif::memes-> {currentwsbi}; #*** submacrok ***#
$Awfif::wsol-> {l}[$atailsi][ $Awfif::memes-> {wsoprev}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$atailsi][ $Awfif::memes-> {wsonext}] = $Awfif::wsbl-> {wsoh} [$Awfif::memes-> {currentwsbi}]; #*** submacrok ***#
# head sentinal
$headsi = addwsoli (\$Awfif::wsol);
$aheadsi = awsoadrd ($headsi);
# fix up the pointers
$Awfif::wsol-> {l}[$aheadsi][ $Awfif::memes-> {wsowsi}] = $Awfif::memes-> {currentwsbi}; #*** submacrok ***#
$Awfif::wsol-> {l}[$aheadsi][ $Awfif::memes-> {wsonext}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$aheadsi][ $Awfif::memes-> {wsoprev}] = $Awfif::wsbl-> {wsoh} [$Awfif::memes-> {currentwsbi}]; #*** submacrok ***#
# and the head's pointers
$ahdptr = awsoadrd ($Awfif::wsbl-> {wsoh} [$Awfif::memes-> {currentwsbi}]);
$Awfif::wsol-> {l}[$ahdptr][ $Awfif::memes-> {wsowsi}] = $Awfif::memes-> {currentwsbi}; #*** submacrok ***#
$Awfif::wsol-> {l}[$ahdptr][ $Awfif::memes-> {wsonext}] = $headsi; #*** submacrok ***#
$Awfif::wsol-> {l}[$ahdptr][ $Awfif::memes-> {wsoprev}] = $tailsi; #*** submacrok ***#
$Awfif::wsbl-> {wsss}[$Awfif::memes-> {currentwsbi}] = 't';
# addwsolitelhd
# add the telomeric root to the tail sentinal of the workspace
&deptelhd ($Awfif::memes-> {currentwsbi});
};#if should create the sentinals
# switch to relative addressing
$nslinkh = grwsoadr ($nslinkh);
# The head is really a relative index of the head of this workspace.
if ( ($Awfif::memes-> {chckadd})
&& (($$list-> {f} < 0)
or ($$list-> {t} <0)
or ($$list-> {f} >= $$list-> {p})
or ($$list-> {t} >= $$list-> {p})
or (($$list-> {f} != 0)
&& ($Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#
or (($$list-> {t} != 0)
&& ($Awfif::wsol-> {l}[$$list-> {t}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#
)
) {&break()};
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("addwsolix ret $nslinkh\n");
};
return $nslinkh
}# addwsolix
#
sub canrejfwso {# The caller can't accept this free chain wso move it from head if can or
my ($pflink, $list) = @_;
my ($result);
$result = '';
if (checkwsmd ($$pflink, $Awfif::memes-> {wsowsi}) != 0) {&break()};
if ($$pflink == $$list-> {t}) {#can't reject this item its the only one
# setup the first list element
else {#can reject this item
my ($of, $ot, $ofws14, $ofws16, $nfws14, $nfws16);
# by moving it to the tail of the free list
# and returning the new head of the free list
$result = 't';
$of = $$list-> {f};
$ot = $$list-> {t};
$ofws14 = $Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsoprev}]; #*** submacrok ***#
$ofws16 = $Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsonext}]; #*** submacrok ***#
$nfws14 = checkwsmd (
$Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsoprev}] #*** submacrok ***#
,$Awfif::memes-> {wsoprev});
$nfws16 = checkwsmd (
$Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsoprev}] #*** submacrok ***#
,$Awfif::memes-> {wsonext});
$$pflink = $Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsoprev}]; #*** submacrok ***#
$$list-> {t} = $of;
# make {f} point to new pflink
# tail the rejected item
$Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsonext}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$of][ $Awfif::memes-> {wsoprev}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$of][ $Awfif::memes-> {wsonext}] = $ot; #*** submacrok ***#
$Awfif::wsol-> {l}[$ot][ $Awfif::memes-> {wsoprev}] = $of; #*** submacrok ***#
};#else
if (($$list-> {f} < 0)
or ($$list-> {t} <0)
or ($$list-> {f} >= $$list-> {p})
or ($$list-> {t} >= $$list-> {p})
or (($$list-> {f} != 0)
&& ($Awfif::wsol-> {l}[$$list-> {f}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#
or (($$list-> {t} != 0)
&& ($Awfif::wsol-> {l}[$$list-> {t}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#
) {&break()};
return $result;
} # canrejfwso
#
sub newwsolink {# This knows the wsobjectl is an array and so free list is absolute addressed
my ($froml, $larrayref) = @_;# currently assumes froml is a relative head address or 0
my ($link, $headsentl);
no strict 'refs';
if ($froml == 0) {#start new set of links
# setup the first list element
$Awfif::wsol-> {l}[$$larrayref-> {p}][ $Awfif::memes-> {wsoprev}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$$larrayref-> {p}][ $Awfif::memes-> {wsonext}] = 0; #*** submacrok ***#
# note the head
$link = $$larrayref-> {p};
if (($Awfif::wsbl-> {wsas}[$Awfif::memes->{currentwsbi}])) {#base and offset need setting up
$Awfif::wsbl-> {l}[$Awfif::memes->{currentwsbi}][2] = $link-1;#base
$Awfif::wsbl-> {l}[$Awfif::memes->{currentwsbi}][3] = 0;#offset
};#setup the ws base and offset
}
else {#add a link to this set
$headsentl = $Awfif::wsol-> {l}[$froml][ $Awfif::memes-> {wsonext}]; #*** submacrok ***#
$Awfif::wsol-> {l}[$froml][ $Awfif::memes-> {wsonext}] = grwsoadr ($$larrayref-> {p}); #*** submacrok ***#
# setup the relative environment
$Awfif::wsol-> {l}[$$larrayref-> {p}][ $Awfif::memes-> {wsoprev}] = grwsoadr($froml); #*** submacrok ***#
if (($Awfif::wsbl-> {wsas}[$Awfif::memes->{currentwsbi}]) && ($Awfif::wsbl-> {wsss}[$Awfif::memes-> {currentwsbi}])) {#head sentinal needs setting up
my ($ahs);
$ahs = awsoadrd ($headsentl);
$Awfif::wsol-> {l}[$$larrayref-> {p}][ $Awfif::memes-> {wsonext}] = $headsentl; #*** submacrok ***#
$Awfif::wsol-> {l}[$ahs][ $Awfif::memes-> {wsoprev}] = grwsoadr ($$larrayref-> {p}); #*** submacrok ***#
}
else {
$Awfif::wsol-> {l}[$$larrayref-> {p}][ $Awfif::memes-> {wsonext}] = 0; #*** submacrok ***#
};#else
# note the head
$link = $$larrayref-> {p};
};
$$larrayref-> {p}++;
return $link;
} # newwsolink
#
# freewso has a bad block structure layout
sub freewso {# This moves a wso to the free list of $Awfif::wsol
my ($awso, $previous, $next, $fprevious, $fnext, $fpws, $fnws, $cwsbi, $zombie, $kws, $rgsponsor);
if (($Awfif::wsol-> {f} < 0)
or ($Awfif::wsol-> {t} <0)
or ($Awfif::wsol-> {f} >= $Awfif::wsol-> {p})
or ($Awfif::wsol-> {t} >= $Awfif::wsol-> {p})
or (($Awfif::wsol-> {f} != 0)
&& ($Awfif::wsol-> {l}[$Awfif::wsol-> {f}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#
or (($Awfif::wsol-> {t} != 0)
&& ($Awfif::wsol-> {l}[$Awfif::wsol-> {t}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#
) {&break()};
$next = 0;
$zombie = '';
$cwsbi = $Awfif::memes-> {currentwsbi};
$awso = awsoadr ($wso);
if ($Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsowsi}] != $cwsbi) { #*** submacrok ***#
$kws = getwsost4 ($wso);
# free the wso descriptors
while ($Awfif::wsol-> {l} [$awso] [2] != 0) {
$Awfif::wsol-> {l} [$awso] [2] = freedesc ($Awfif::wsol-> {l} [$awso] [2]);
};#while
while ($Awfif::wsol-> {l} [$awso] [8] != 0) {
$Awfif::wsol-> {l} [$awso] [8] = freedesc ($Awfif::wsol-> {l} [$awso] [8]);
};#while
# set wsol [2], [8], [10], [13] descriptor data to 0
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsologucount}] = 0; #*** submacrok ***#
$rgsponsor = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogcsponsor}]; #*** submacrok ***#
if ($rgsponsor != 0) {
my ($ngcsponsor);
$ngcsponsor =
$Awfif::wsol-> {l}[awsoadr ($rgsponsor)][ $Awfif::memes-> {wsogcsponsor}]; #*** submacrok ***#
if (($Awfif::memes-> {freewsongcspbreak}) && ($ngcsponsor != 0) && ($Awfif::memes-> {currentwsbi} == 3)) {&break ()};
$Awfif::wsol-> {l}[awsoadr ($rgsponsor)][ $Awfif::memes-> {wsogcsponsor}] = 0; #*** submacrok ***#
};#if
# remember the wso details
$Awfif::wsol->{flistl}++;
$previous = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoprev}]; #*** submacrok ***##follow from the head back through previous
$next = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}]; #*** submacrok ***#
$fprevious = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobkwl}]; #*** submacrok ***#
$fnext = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsofkwl}]; #*** submacrok ***#
$fpws = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobws}]; #*** submacrok ***#
$fnws = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsofws}]; #*** submacrok ***#
# freewsocc
# clear out the cached details
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobastype}] = undef(); #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobasind}] = undef(); #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsopkpos}] = undef(); #*** submacrok ***#
# freewsobf
$Awfif::wsol-> {fbs} [$awso] = undef ();
# if this wso is the master of a keyword this info must be moved to the next in chain
if ($Awfif::wsol-> {l} [$awso][4] ne '') {
if ($Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsofkwl}] != 0) { #*** submacrok ***#
$Awfif::wsol-> {l} [$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsofkwl}]][4] = $Awfif::wsol-> {l} [$awso][4]; #*** submacrok ***#
}
else {
};#if
# or if there is none this wso must remain as a zombie linked into the keyword list
# not sure how to do that correctly or if it can occur
# purge the contents of the wso
$Awfif::wsol-> {l} [$awso] = ();
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobkwl}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsofkwl}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobasind}] = 0; #*** submacrok ***#
$rgsponsor = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogcsponsor}]; #*** submacrok ***#
if ($rgsponsor != 0) {
my ($ngcsponsor);
$ngcsponsor =
$Awfif::wsol-> {l}[awsoadr ($rgsponsor)][ $Awfif::memes-> {wsogcsponsor}]; #*** submacrok ***#
if (($Awfif::memes-> {freewsongcspbreak}) && ($ngcsponsor != 0) && ($Awfif::memes-> {currentwsbi} == 3)) {&break ()};
$Awfif::wsol-> {l}[awsoadr ($rgsponsor)][ $Awfif::memes-> {wsogcsponsor}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[awsoadr ($rgsponsor)][ $Awfif::memes-> {wsogcsponsored}] = 0; #*** submacrok ***#
};#if
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogcsponsor}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogcsponsored}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoprev}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsowsi}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobws}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsofws}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoitstr}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsotdg}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsofgrp}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsotdb}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobug}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoisterm}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobti}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsobus}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogcjhlsi}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsohistbp}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogcspjhlsi}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsocstarts}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsocbegins}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsopkwsi}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsosyncl}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsosponsorgs}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsosponsort}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsosubpid}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogstart}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsogend}] = 0; #*** submacrok ***#
# link the wso into the free list
if ($Awfif::wsol-> {f} == $Awfif::wsol-> {t}) {
# empty free list
if ($Awfif::wsol-> {f} == 0) {
$Awfif::wsol-> {f} = $awso;
$Awfif::wsol-> {t} = $awso;
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoprev}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}] = 0; #*** submacrok ***#
}# 0
else {#just one element in the free list - adding new element to be head
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoprev}] = $Awfif::wsol-> {f}; #*** submacrok ***#
$Awfif::wsol-> {f} = $awso;
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}] = 0; #*** submacrok ***#
$Awfif::wsol-> {l}[$Awfif::wsol-> {t}][ $Awfif::memes-> {wsonext}] = $awso; #*** submacrok ***#
};#else
}#if
else {#add at the free head
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoprev}] = $Awfif::wsol-> {f}; #*** submacrok ***#
$Awfif::wsol-> {l}[$Awfif::wsol-> {f}][ $Awfif::memes-> {wsonext}] = $awso; #*** submacrok ***#
$Awfif::wsol-> {f} = $awso;
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}] = 0; #*** submacrok ***#
};#else
# link the workspace together - this assumption will not work for deleting the final wso
$Awfif::wsol-> {l}[awsoadr ($previous)][ $Awfif::memes-> {wsonext}] = $next; #*** submacrok ***#
# freewswinu
# if the wso is in the workspace window then move the window to the previous
if ($Awfif::wsbl-> {winkwp} [$cwsbi] == $wso) {
$Awfif::wsbl-> {winkwp} [$cwsbi] = $previous;
};#if
if ($Awfif::wsbl-> {winkwpr} [$cwsbi] == $wso) {
$Awfif::wsbl-> {winkwpr} [$cwsbi] = $previous;
};#if
$Awfif::wsol-> {l}[awsoadr ($next)][ $Awfif::memes-> {wsoprev}] = $previous; #*** submacrok ***#
# link the function list together
$Awfif::memes-> {currentwsbi} = $fpws;
$Awfif::wsol-> {l}[awsoadr ($fprevious)][ $Awfif::memes-> {wsofkwl}] = $fnext; #*** submacrok ***#
$Awfif::wsol-> {l}[awsoadr ($fprevious)][ $Awfif::memes-> {wsofws}] = $fnws; #*** submacrok ***#
$Awfif::memes-> {currentwsbi} = $fnws;
$Awfif::wsol-> {l}[awsoadr (awsoadr ($fnext))][ $Awfif::memes-> {wsobkwl}] = $fprevious; #*** submacrok ***#
$Awfif::wsol-> {l}[awsoadr ($fnext)][ $Awfif::memes-> {wsobws}] = $fpws; #*** submacrok ***#
#
# correct the hash pointers if the deleted wso was addressed by the hash
if (($Awfif::memes-> {keywordwsih}-> {$kws} == $cwsbi)
&& ($Awfif::memes-> {keywordh}-> {$kws} == $wso)
){
$Awfif::memes-> {keywordh}-> {$kws} = $fprevious;
$Awfif::memes-> {keywordwsih}-> {$kws} = $fpws;
};
if (($Awfif::wsol-> {f} < 0)
or ($Awfif::wsol-> {t} <0)
or ($Awfif::wsol-> {f} >= $Awfif::wsol-> {p})
or ($Awfif::wsol-> {t} >= $Awfif::wsol-> {p})
or (($Awfif::wsol-> {f} != 0)
&& ($Awfif::wsol-> {l}[$Awfif::wsol-> {f}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#
or (($Awfif::wsol-> {t} != 0)
&& ($Awfif::wsol-> {l}[$Awfif::wsol-> {t}][ $Awfif::memes-> {wsowsi}] != 0) ) #*** submacrok ***#
) {&break()};
$Awfif::memes-> {currentwsbi} = $cwsbi;
return $next;
} # freewso
#
sub toofewwso {# This checks the wso list has at least count members from s to e or 0
my ($wsoe, $wsos, $mint) = @_;
my ($result, $rlink, $count);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("toofewwso wsoe $wsoe wsos $wsos mint $mint ");
};
$result = 't';
$rlink = $wsos;
$count = $mint;
while (($rlink != $wsoe) && (awsoadr($rlink) != 0) && (($count--) != 0) && (($rlink = trwsoadr ($rlink, 1)) != 0)) {
if ((wsbasetype ($rlink) == $Awfif::memes-> {snnh}{ichar})
or (wsbasetype ($rlink) == $Awfif::memes-> {snnh}{whitespace})) {# not valid inc count
if ($count <= 0) {
};
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("toofewwsox ret ($result)\n");
};
return $result;
} # toofewwso
#
sub greaterwso {# This returns true if wso2 follows in list after wso1
my ($wso2, $wso1) = @_;
my ($result, $rlink);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("greaterwso wso2 $wso2 wso1 $wso1 ");
};
$result = '';
$rlink = $wso1;
if (trwsoadr ($rlink, -1) != $wso2) {#if wso2 is pred of wso1 then just return false
while (($rlink != $wso2) && (awsoadr($rlink) != 0) && (($rlink = trwsoadr ($rlink, 1)) != 0)) {
if ($rlink == $wso2) {
};#while
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("greatergwsox ret ($result)\n");
};
return $result;
} # greaterwso
#
sub greatergwso {# This returns true if wso2 follows in list after wso1
my ($wso2, $wso1) = @_;
my ($result, $rlink);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("greatergwso wso2 $wso2 wso1 $wso1 ");
};
$result = '';
$rlink = $wso1;
if ($wso1 == $Awfif::wsbl->{wsft}[$Awfif::memes-> {currentwsbi}]) {
$result = 't';#for a group assume that wso2 must be above the fast tail
}#if
elsif ($wso2 == $Awfif::wsbl->{wsoh}[$Awfif::memes-> {currentwsbi}]) {
elsif ($wso2 == $Awfif::wsbl->{wsft}[$Awfif::memes-> {currentwsbi}]) {
$result = '';#for a group assume that wso2 must be above the fast tail
}#if
elsif ($wso1 == $Awfif::wsbl->{wsoh}[$Awfif::memes-> {currentwsbi}]) {
elsif (trwsoadr ($rlink, -1) != $wso2) {#if wso2 is pred of wso1 then just return false
while (($rlink != $wso2) && (awsoadr($rlink) != 0) && (wsbasetype ($rlink) != $Awfif::memes->{snnh}{ichar}) && (($rlink = trwsoadr ($rlink, 1)) != 0)) {
if ($rlink == $wso2) {
};#while
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("greatergwsox ret ($result)\n");
};
return $result;
} # greatergwso
#
sub setfwst {# This sets the fast workspace tail
my ($wsoe, $wsos, $ws) = @_;
my ($result, $rlink, $found, $cwsbi);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("setfwst wsoe $wsoe wsos $wsos");
};
$result = $wsos;
$found = '';
$rlink = $wsos;
$cwsbi = $Awfif::memes-> {currentwsbi};
$Awfif::memes-> {currentwsbi} = $ws;
while ((!($found)) && ($rlink != $wsoe) && (awsoadr($rlink) != 0) ) {
if ((wsbasetype ($rlink) == $Awfif::memes-> {snnh}{ichar})
or (wsbasetype ($rlink) == $Awfif::memes-> {snnh}{whitespace})) {# not valid inc count
else {
$found = 't';
$result = $rlink;
};#else
if (($rlink = trwsoadr ($rlink, 1)) == 0) {
};#while
$Awfif::memes-> {currentwsbi} = $cwsbi;
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("setfwstx ret ($result)\n");
};
return $result;
} # setfwst
#
sub stripichar {# This consolidates all the white space and ichar blocks of more than two items - leaving two actively in place
my ($wsoe, $ws) = @_;
my ($result, $rlink, $orlink, $count, $cwsbi, $succeeded);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("stripichar wsoe $wsoe ws $ws ");
};
$succeeded = 't';
$count = 0;
$cwsbi = $Awfif::memes-> {currentwsbi};
$Awfif::memes-> {currentwsbi} = $ws;
$rlink = trwsoadr ($Awfif::wsbl-> {wsft}[$ws], 1);
while ( ($rlink != $wsoe) && (awsoadr($rlink) != 0) && ($succeeded) ){
if (((wsbasetype ($rlink) == $Awfif::memes-> {snnh}{ichar}) )
or ((wsbasetype ($rlink) == $Awfif::memes-> {snnh}{whitespace}) ) ) {# not valid inc count
$count++;
$rlink = trwsoadr ($rlink, 1);
};#if
$orlink = $rlink;
$rlink = trwsoadr ($rlink, 1);
$succeeded = relinkwsobwsft ($orlink);
};#if
}#if have some enough to relink
else {
$count = 0;
$rlink = trwsoadr ($rlink, 1);
};#else
};
$Awfif::memes-> {currentwsbi} = $cwsbi;
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("stripicharx ret ($result)\n");
};
return $result;
} # stripichar
#
sub relinkwsobwsft {# This relinks a wso so that it is logically in the set prior to the fast tail wsft
my ($wso) = @_;
my ($awso, $previous, $next, $cwsbi, $result);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("relinkwsobwsft wso $wso");
};
$result = '';
$cwsbi = $Awfif::memes-> {currentwsbi};
$awso = awsoadr ($wso);
# remember the wso details
$previous = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsoprev}];#*** submacrok ***##follow from the head back through previous
$next = $Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}];#*** submacrok ***#
# link the wso into the pre wsft list
if ( ($Awfif::wsbl-> {wsft}[$cwsbi] ne '')
&& ($Awfif::wsbl-> {wsft}[$cwsbi] != $Awfif::wsbl-> {wsot}[$cwsbi])
) {
# relink the wso
$result = 't';
if ($Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsohistbp}] != 0) {#*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsohistbp}] = 0;#*** submacrok ***#
};
&setwsmd ($awso, $Awfif::memes-> {wsoprev},
$Awfif::wsol-> {l}[awsoadr ($Awfif::wsbl-> {wsft}[$cwsbi])][ $Awfif::memes-> {wsoprev}]#*** submacrok ***#
$Awfif::wsol-> {l}[$awso][ $Awfif::memes-> {wsonext}] = $Awfif::wsbl-> {wsft}[$cwsbi];#*** submacrok ***#
# link the two associates together
$Awfif::wsol-> {l}[awsoadr ($next)][ $Awfif::memes-> {wsoprev}] = $previous;#*** submacrok ***#
$Awfif::wsol-> {l}[awsoadr ($previous)][ $Awfif::memes-> {wsonext}] = $next;#*** submacrok ***#
# link the two new associates to the wso
&setwsmd ( awsoadr (
$Awfif::wsol-> {l}[awsoadr($Awfif::wsbl-> {wsft}[$cwsbi])][$Awfif::memes-> {wsoprev} ]#*** submacrok ***#
), $Awfif::memes-> {wsonext}, $wso);
$Awfif::wsol-> {l}[ awsoadr ($Awfif::wsbl-> {wsft}[$cwsbi])][ $Awfif::memes-> {wsoprev}] = $wso;#*** submacrok ***#
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("relinkwsobwsftx ret ($result)\n");
};
return $result
} # relinkwsobwsft
#
sub checkwsbf {# This supports the addressing of a two bit flag in the wso bit vector
my ($awso, $index) = @_;
my ($result);
# if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
# print ("checkwsbf awso $awso index $index ");
# };
if ($Awfif::memes-> {usewsobfdirect}) {
$result = $Awfif::wsolfbs [$awso] [$index - $Awfif::memes-> {flagsoffset}];
}#if
else {
$result = vec ($Awfif::wsolfbs [$awso * $Awfif::memes-> {maxfbs}], ($index - $Awfif::memes-> {flagsoffset}), 2);
};#else
# if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
# print ("checkwsbfx ret ($result)\n");
# };
return $result
} # checkwsbf
#
sub setwsbf {# This supports the addressing and setting of a two bit flag in the wso bit vector
my ($awso, $index, $value) = @_;
# if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
# print ("setwsbf awso $awso index $index value $value ");
# };
if ($Awfif::memes-> {usewsobfdirect}) {
$Awfif::wsolfbs [$awso] [$index - $Awfif::memes-> {flagsoffset}] = $value;
}#if
else {
vec ($Awfif::wsolfbs [$awso * $Awfif::memes-> {maxfbs}], ($index - $Awfif::memes-> {flagsoffset}), 2) = $value;
};#else
# if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
# print ("setwsbfx \n");
# };
#<!-- start tag uts -->
#
sub checkwsmd { #*** ndefmacro ***#
my ($awso, $index) = @_; #*** pdefmacro ***#
my ($result);
# This supports the addressing of mapped data in the wso vector storage
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("checkwsmd awso $awso index $index ");
};
if ($Awfif::memes-> {usewsodirect}) {
$result = $Awfif::wsol-> {l}[$awso][$index]; #*** repdefmacro ***#
}#if
elsif (($index == $Awfif::memes-> {wsobkwl})
or ($index == $Awfif::memes-> {wsofkwl})
or ($index == $Awfif::memes-> {wsobasind})
or ($index == $Awfif::memes-> {wsogcsponsor})
or ($index == $Awfif::memes-> {wsogcsponsored})
or ($index == $Awfif::memes-> {wsotdb})
or ($index == $Awfif::memes-> {wsobug})
or ($index == $Awfif::memes-> {wsoisterm})
or ($index == $Awfif::memes-> {wsobti})
or ($index == $Awfif::memes-> {wsobus})
or ($index == $Awfif::memes-> {wsoitstr})
or ($index == $Awfif::memes-> {wsotdg})
or ($index == $Awfif::memes-> {wsogstart})
or ($index == $Awfif::memes-> {wsogend})
){
$result = unpack ("l", pack ("L", vec ($Awfif::wsoli32s, (($awso * $Awfif::memes-> {maxm32}) + $Awfif::m32[$index]), 32)));
}#elsif
elsif (($index == $Awfif::memes-> {wsowsi})
or ($index == $Awfif::memes-> {wsobws})
or ($index == $Awfif::memes-> {wsofws})
or ($index == $Awfif::memes-> {wsobastype})
or ($index == $Awfif::memes-> {wsogcspjhlsi})
or ($index == $Awfif::memes-> {wsogcjhlsi})
or ($index == $Awfif::memes-> {wsopkwsi})
or ($index == $Awfif::memes-> {wsocbegins})
or ($index == $Awfif::memes-> {wsocstarts})
or ($index == $Awfif::memes-> {wsopkpos})
or ($index == $Awfif::memes-> {wsologucount})
or ($index == $Awfif::memes-> {wsosubpid})
or ($index == $Awfif::memes-> {wsosponsorgs})
or ($index == $Awfif::memes-> {wsosponsort})
){
$result = vec ($Awfif::wsoli16s, (($awso * $Awfif::memes-> {maxm16}) + $Awfif::m16[$index]), 16);
}#elsif
elsif (($index == $Awfif::memes-> {wsofgrp})
or ($index == $Awfif::memes-> {wsologaei})
){
$result = vec ($Awfif::wsolu32s, (($awso * $Awfif::memes-> {maxmu32}) + $Awfif::mu32[$index]), 32);
elsif (($index == $Awfif::memes-> {wsohistbp})
){
$result = $Awfif::wsol-> {l} [$awso][9];
};#elsif
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("checkwsmdx ret ($result)\n");
};
return $result #*** rdefmacro ***#
} # checkwsmd
#<!-- end tag uts -->
#
sub setwsmd {# This supports the addressing and setting of a mapped data in the wso vector storage #*** ndefmacro ***#
my ($awso, $index, $value) = @_; #*** pdefmacro ***#
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("setwsmd awso $awso index $index value $value ");
};
if ($Awfif::memes-> {usewsodirect}) {
$Awfif::wsol-> {l}[$awso][$index] = $value; #*** repdefmacro ***#
}#if
elsif (($index == $Awfif::memes-> {wsobkwl})
or ($index == $Awfif::memes-> {wsofkwl})
or ($index == $Awfif::memes-> {wsobasind})
or ($index == $Awfif::memes-> {wsogcsponsor})
or ($index == $Awfif::memes-> {wsogcsponsored})
or ($index == $Awfif::memes-> {wsoprev})
or ($index == $Awfif::memes-> {wsonext})
or ($index == $Awfif::memes-> {wsotdb})
or ($index == $Awfif::memes-> {wsobug})
or ($index == $Awfif::memes-> {wsoisterm})
or ($index == $Awfif::memes-> {wsobti})
or ($index == $Awfif::memes-> {wsobus})
or ($index == $Awfif::memes-> {wsoitstr})
or ($index == $Awfif::memes-> {wsotdg})
or ($index == $Awfif::memes-> {wsogstart})
or ($index == $Awfif::memes-> {wsogend})
){
vec ($Awfif::wsoli32s , (($awso * $Awfif::memes-> {maxm32}) + $Awfif::m32[$index]), 32) = $value;
}#if
elsif (($index == $Awfif::memes-> {wsowsi})
or ($index == $Awfif::memes-> {wsobws})
or ($index == $Awfif::memes-> {wsofws})
or ($index == $Awfif::memes-> {wsobastype})
or ($index == $Awfif::memes-> {wsogcspjhlsi})
or ($index == $Awfif::memes-> {wsogcjhlsi})
or ($index == $Awfif::memes-> {wsopkwsi})
or ($index == $Awfif::memes-> {wsocbegins})
or ($index == $Awfif::memes-> {wsocstarts})
or ($index == $Awfif::memes-> {wsopkpos})
or ($index == $Awfif::memes-> {wsologucount})
or ($index == $Awfif::memes-> {wsosubpid})
or ($index == $Awfif::memes-> {wsosponsorgs})
or ($index == $Awfif::memes-> {wsosponsort})
){
vec ($Awfif::wsoli16s , (($awso * $Awfif::memes-> {maxm16}) + $Awfif::m16[$index]), 16) = $value;
}#elsif
elsif (($index == $Awfif::memes-> {wsofgrp})
or ($index == $Awfif::memes-> {wsologaei})
){
vec ($Awfif::wsolu32s, (($awso * $Awfif::memes-> {maxmu32}) + $Awfif::mu32[$index]), 32) = $value;
}#elsif
elsif (($index == $Awfif::memes-> {wsohistbp})
){
$Awfif::wsol-> {l} [$awso][9] = $value;
};#elsif
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("setwsmdx \n");
};
} # setwsmd
#
#
sub inewstws {
my ($myli, $buffers, $grkwp, $grkwpr, $sponsor, $makesubprogram) = @_;
#
# create a new structural workspace
return isetupws ($myli, $buffers, $grkwp, $grkwpr, $sponsor, $makesubprogram);
}#inewstws
#<!-- start tag scl -->
#
sub inewaws {
my ($myli, $buffers, $grkwp, $grkwpr, $sponsor, $makesubprogram) = @_;
#
# create a new active workspace
#
return isetupws ($myli, $buffers, $grkwp, $grkwpr, $sponsor, $makesubprogram, undef (), 't');
}#iaddsg
#
sub iaddsg {
my ($myli, $buffers, $grkwp, $grkwpr, $sponsor, $usews) = @_;
#
# add a group to a structural workspace
#
return isetupws ($myli, $buffers, $grkwp, $grkwpr, $sponsor, undef (), $usews);
}#iaddsg
#
sub isetupws {
my ($myli, $buffers, $grkwp, $grkwpr, $sponsor, $makesubprogram, $usews, $makeactive) = @_;
#
# create a new structural workspace
my ($tws, $buffer, $active, $depstag, $depttag, $dephtag, $insymbol, @inmsymbol, @started, $end, $cwsbi, $setwsclinv, $binding);
#
# checked for merged workspaces
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("isetupws buffers($$buffers) grkwp $$grkwp grkwpr $grkwpr sponsor $sponsor ");
if (defined ($makesubprogram)) {
print ("makesubprogram $makesubprogram ");
};#if
if (defined ($usews)) {
print ("usews $usews ");
};#if
if (defined ($makeactive)) {
print ("makeactive $makeactive ");
};#if
};
$cwsbi = $Awfif::memes-> {currentwsbi};
if (defined ($makesubprogram)) {
$binding = $makesubprogram;
}#if
else {
$binding = $Awfif::memes-> {snnh} {stbinding};
};#else
if (!defined ($usews)) {
if ((defined ($makeactive)) && ($makeactive)) {
$active = $makeactive;
$buffer = $$buffers;
}#if
else {
$active = '';
$buffer = '(<rhlmspg>';
$buffer = $buffer . $$buffers;
$buffer = $buffer . '</rhlmspg>)';
};#else
$Awfif::wsbl-> {wsactive}[$tws] = $active;#default the workspace to being processed by the coderack structural workspaces may be inactive
$depstag = '';
$depttag = 0;
$dephtag = 0;
$insymbol = '';
@inmsymbol = ();
$started[0] = 0;
$started[1] = 't';
$setwsclinv = '';
&convbws ($myli, \$buffer, \$$grkwp, $grkwpr, $Awfif::memes-> {kwmi}, $Awfif::memes-> {kwmir}, $sponsor, \$insymbol, \@inmsymbol, \@started, \$end, \$depstag, \$depttag, \$dephtag, $tws, $binding,
$Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {budesc}],
'', #dont energize the base types
\$setwsclinv
);
$Awfif::wsbl-> {wsft} [$tws] = setfwst ($Awfif::wsbl-> {wsbloh} [$tws], $Awfif::wsbl-> {wsot}[$tws], $tws);
$Awfif::memes-> {currentwsbi} = $cwsbi;
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("isetupwsx ret $tws\n");
};
return $tws;
}#isetupws
#
#<!-- end tag scl -->
#<!-- start tag vbt -->
#<!-- start tag aso -->
#<!-- start tag sca -->
#
sub igoalscon1 {# setup the goal suppressor for general cascade participant
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static, $strategy)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("igoalscon1 myli $myli sti($sti) kwp($$kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {$strategy});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {selector});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("igoalsconx ret ($labcount)\n");
};#if
return $labcount
}# igoalscon1
#
#<!-- end tag sca -->
#<!-- end tag vbt -->
#<!-- end tag aso -->
#
sub goalscon1 {# setup the goal suppressor for general cascade participant
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (igoalscon1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, getwsost4 ($Awfif::codelet-> {l} [$myli][21])));
}# goalscon1
#
sub devscon1 {# setup the goal suppressor for dev codelet
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (igoalscon1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'development'));
}# devscon1
#
#<!-- start tag vbt -->
#
sub vbtdevscon1 {# setup the goal suppressor for vbtdev codelet
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (igoalscon1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'development'));
}# vbtdevscon1
#
sub vbtiopscon1 {# setup the goal suppressor for vbtiop codelet
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (igoalscon1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'vbt'));
}# vbtiopscon1
#<!-- end tag vbt -->
#<!-- start tag aso -->
#
sub msiopscon1 {# setup the goal suppressor for msiop codelet
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (igoalscon1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'mergestreams'));
}# msiopscon1
#<!-- start tag sca -->
#
sub hdoscon1 {# setup the goal suppressor for msiop codelet
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (igoalscon1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'hdo'));
}# hdoscon1
#<!-- end tag sca -->
#<!-- end tag aso -->
#
##################### end strategy routines ################ ################## #########
#
##################### label strategy routines ################ ################## #########
#<!-- start tag ssc -->
#
sub statementlabel1 {# setup the labels for statement
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("statementlabel myli $myli sti $sti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {model});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {statementcategory});
$labcount = labload (\@$lab, $labcount, wsbasetype ($sti));
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {statementcomplete});
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("statementlabelx ret ($labcount)\n");
};
return $labcount
}# statementlabel
#
#<!-- start tag swp -->
#
sub partlabel1 {# setup the labels for part
my($myli, $parti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("partlabel myli $myli parti $parti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {model});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {partscategory});
$labcount = labload (\@$lab, $labcount, wsbasetype ($parti));
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {groupcomplete});
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("partlabelx ret ($labcount)\n");
};
return $labcount
}# partlabel
#
#<!-- end tag ssc -->
#<!-- end tag swp -->
#<!-- start tag scs -->
#<!-- start tag sca -->
#
sub statementpdcal1 {# setup the labels for statement
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount, $concept, $drefi, $cwsbi);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("statementpdcal myli $myli sti $sti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");
};
# updated for merged workspaces
$cwsbi = $Awfif::memes-> {currentwsbi};
$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l}[$myli] [20];
$labcount = 0;
&findcounter ($Awfif::wsol-> {l} [awsoadr ($sti)][2], ($Awfif::memes-> {snnh}{pdcaprogram}), \$drefi);
if ($drefi != 0) {
$concept = ($Awfif::workspace-> {l} [$drefi] [2] - $Awfif::memes-> {snnh}{wsi});
};#if
if (($drefi != 0) && ($concept != 0)) {
$labcount = labload (\@$lab, $labcount, $concept);
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {program});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {initiate});
};#if
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
$Awfif::memes-> {currentwsbi} = $cwsbi;
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("statementpdcalx ret ($labcount)\n");
};
return $labcount
}# statementpdcal
#
#<!-- end tag sca -->
#<!-- start tag scl -->
#
sub screplicate1 {# setup the labels for statement
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount, $concept, $drefi, $cwsbi);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("screplicate myli $myli sti $sti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");
};
# updated for merged workspaces
$cwsbi = $Awfif::memes-> {currentwsbi};
$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l}[$myli] [20];
$labcount = 0;
&findcounter ($Awfif::wsol-> {l} [awsoadr ($sti)][2], ($Awfif::memes-> {snnh}{pdcaprogram}), \$drefi);
if ($drefi != 0) {
$concept = ($Awfif::workspace-> {l} [$drefi] [2] - $Awfif::memes-> {snnh}{wsi});
};#if
if (($drefi != 0) && ($concept != 0)) {
$labcount = labload (\@$lab, $labcount, $concept);
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {replication});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {initiate});
};#if
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
$Awfif::memes-> {currentwsbi} = $cwsbi;
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("screplicatex ret ($labcount)\n");
};
return $labcount
}# screplicate
#
#<!-- end tag scl -->
#<!-- start tag ssc -->
#
sub developmentlabel1 {# setup the labels for development
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("developmentlabel myli $myli sti $sti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {model});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {devcategory});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {development});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {statementcomplete});
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - can cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("developmentlabelx ret ($labcount)\n");
};
return $labcount
}# developmentlabel
#
#<!-- end tag ssc -->
#
sub developmentb1 {# setup the binding for development binder
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("developmentb1 myli $myli sti $sti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {development});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - can cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("developmentbx ret ($labcount)\n");
};
return $labcount
}# developmentb
#
#<!-- start tag vbt -->
#<!-- start tag dli -->
#
sub developmenti1 {# setup the labels for development initiator signaling
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (iinitiators1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'development'));
}# developmenti1
#
sub binderp11 {# setup the labels for binder base context
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("binderp11 myli $myli sti $sti ");
if (defined ($kwp)) {
print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};#if
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][21]));
if ((defined ($Awfif::codelet-> {l} [$myli] [36])) && ($Awfif::codelet-> {l} [$myli] [36] > 0) ){
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {subprogram});
};#if
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("binderp11x ret ($labcount)\n");
};
return $labcount
}# binderp11
#
sub binderc1 {# setup the labels for binder indirect context
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount, $i, $cwsbi, $conforms, $ssloc, $shistone, $ri);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("binderc1 myli $myli sti $sti ");
if (defined ($kwp)) {
print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};#if
};
# updated for merged workspaces
$cwsbi = $Awfif::memes-> {currentwsbi};
$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
for ($i = trwsoadr($Awfif::codelet-> {l} [$myli][21],2);
( (!($shistone = chmdefis ($myli, trwsoadr ($i,-1), $Awfif::memes-> {snnh}{histone}, \$conforms)))
&& ($i != trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2) )
&& ($ri = $i)
&& (!($ssloc = chmdefis ($myli, trwsoadr ($i,2), $Awfif::memes-> {snnh}{sloc}, \$conforms))));
$i = trwsoadr ($i,1)) {
$labcount = labload (\@$lab, $labcount, wsbasetype ($i));
};#for
if ($shistone) {#already done it
if ($Awfif::memes-> {binderchis}) {&break()};
}#if
elsif ($ssloc) {
$labcount = labload (\@$lab, $labcount, wsbasetype ($ri));
}#elsif
else {
$labcount = labload (\@$lab, $labcount, wsbasetype (trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2)));
};#else
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
$Awfif::memes-> {currentwsbi} = $cwsbi;
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("binderc1x ret ($labcount)\n");
};
return $labcount
}# binderc1
#
#<!-- start tag aso -->
#
sub ibindervc1 {# setup the labels for app complex indirect context (with variable end)
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static, $tback, $ihforward)=@_;
my ($labcount, $i, $initi, $hforward, $cwsbi);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("bindercs1 myli $myli sti $sti ");
if (defined ($ihforward)) {
print ("ihforward($ihforward) ");
};#if
if (defined ($kwp)) {
print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};#if
};
# updated for merged workspaces
$labcount = 0;
if (defined ($ihforward)) {
$hforward = $ihforward;
}#if
else {
$cwsbi = $Awfif::memes-> {currentwsbi};
$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
for ($i = ($initi = trwsoadr($Awfif::codelet-> {l} [$myli][21], $hforward));
$i != trwsoadr ($Awfif::codelet-> {l} [$myli][22], - $tback, $initi);
$i = trwsoadr ($i,1)) {
$labcount = labload (\@$lab, $labcount, wsbasetype ($i));
};#for
$labcount = labload (\@$lab, $labcount, wsbasetype (trwsoadr ($Awfif::codelet-> {l} [$myli][22], - $tback)));
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
$Awfif::memes-> {currentwsbi} = $cwsbi;
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("bindervc1x ret ($labcount)\n");
};
return $labcount
}# ibindervc1
#
#<!-- end tag aso -->
#<!-- end tag vbt -->
#
sub bindercs1 {# setup the labels for semantic binder complex indirect context
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 3));
}# bindercs1
#
#<!-- start tag vbt -->
#
sub binderc41 {# setup the labels for vbttom00nc binder complex indirect context
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 4));
}# binderc41
#
sub binderc71 {# setup the labels for vbttom00c10 binder complex indirect context
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 7));
}# binderc71
#
sub binderc91 {# setup the labels for vbttom00c10c01 binder complex indirect context
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 9));
}# binderc91
#
sub binderc101 {# setup the labels for vbttom00c10c00 binder complex indirect context
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 10));
}# binderc111
#
sub binderc111 {# setup the labels for vbttom00c10c01c00 binder complex indirect context
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 11));
}# binderc111
#
sub binderc131 {# setup the labels for vbttom01c00c11c02 binder complex indirect context
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 13));
}# binderc131
#
sub binderc161 {# setup the labels for vbttom01c00c01c11c02 binder complex indirect context
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 16));
}# binderc161
#
sub binderc191 {# setup the labels for vbttom11c21c11c12c01c10 binder complex indirect context
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 19));
}# binderc191
#<!-- end tag vbt -->
#
#
sub bindercs21 {# setup the labels for semantic binder complex indirect context
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 4));
}# bindercs21
#
#<!-- start tag aso -->
#<!-- start tag sir -->
#
sub bindercst1 {# setup the labels for binder indirect context
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount, $i, $cwsbi, $conforms, $ssloc, $shistone, $ri);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("bindercst1 myli $myli sti $sti ");
if (defined ($kwp)) {
print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};#if
};
# updated for merged workspaces
$cwsbi = $Awfif::memes-> {currentwsbi};
$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
for ($i = trwsoadr($Awfif::codelet-> {l} [$myli][21],2);
( (!($shistone = chmdefis ($myli, trwsoadr ($i,-1), $Awfif::memes-> {snnh}{histone}, \$conforms)))
&& ($i != trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2) )
&& ($ri = $i)
&& (!($ssloc = chmdefis ($myli, trwsoadr ($i,2), $Awfif::memes-> {snnh}{sloc}, \$conforms))));
$i = trwsoadr ($i,1)) {
$labcount = labload (\@$lab, $labcount, wsbasetype ($i));
};#for
if ($shistone) {#already done it
if ($Awfif::memes-> {binderchis}) {&break()};
}#if
elsif ($ssloc) {
$labcount = labload (\@$lab, $labcount, wsbasetype ($ri));
}#elsif
else {
$labcount = labload (\@$lab, $labcount, wsbasetype (trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2)));
};#else
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
$Awfif::memes-> {currentwsbi} = $cwsbi;
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("bindercst1x ret ($labcount)\n");
};
return $labcount
}# bindercst1
#
#<!-- end tag sir -->
#<!-- end tag aso -->
#<!-- start tag vbt -->
#
sub casoppi1 {# setup the labels for development integration
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount, $i, $cwsbi);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("casoppi1 myli $myli sti $sti ");
if (defined ($kwp)) {
print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};#if
};
# updated for merged workspaces
$cwsbi = $Awfif::memes-> {currentwsbi};
$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][21]));
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 4);
$i != $Awfif::codelet-> {l} [$myli][22];
$i = trwsoadr ($i,1)) {
$labcount = labload (\@$lab, $labcount, wsbasetype ($i));
};#for
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));
$Awfif::memes-> {currentwsbi} = $cwsbi;
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("casoppi1x ret ($labcount)\n");
};
return $labcount
}# casoppi1
#
#<!-- end tag vbt -->
#<!-- end tag dli -->
#
sub cassuboppi1 {# setup the labels for subprogram integration
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount, $i, $cwsbi);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("casoppi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$cwsbi = $Awfif::memes-> {currentwsbi};
$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][21]));
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 4);
$i != $Awfif::codelet-> {l} [$myli][22];
$i = trwsoadr ($i,1)) {
$labcount = labload (\@$lab, $labcount, wsbasetype ($i));
};#for
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));
$Awfif::memes-> {currentwsbi} = $cwsbi;
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("casoppi1x ret ($labcount)\n");
};
return $labcount
}# cassuboppi1
#
#<!-- start tag aso -->
#
sub casopai1 {# setup the labels for development integration
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount, $i, $cwsbi);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("casopai1 myli $myli sti $sti ");
if (defined ($kwp)) {
print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};#if
};
# updated for merged workspaces
$cwsbi = $Awfif::memes-> {currentwsbi};
$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][21]));
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 2);
$i != $Awfif::codelet-> {l} [$myli][22];
$i = trwsoadr ($i,1)) {
$labcount = labload (\@$lab, $labcount, wsbasetype ($i));
};#for
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));
$Awfif::memes-> {currentwsbi} = $cwsbi;
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("casopai1x ret ($labcount)\n");
};
return $labcount
}# casopai1
#
#<!-- end tag aso -->
#
sub goalsupp1 {# setup the binding for goal suppressor
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("goalsupp1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {partconstrained});
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("goalsuppx ret ($labcount)\n");
};
return $labcount
}# goalsupp
#<!-- end tag cr -->
#<!-- start tag aso -->
#
sub mergestreamsb1 {# setup the binding for mergestreams binder
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("mergestreamsb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {mergestreams});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - can cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("mergestreamsbx ret ($labcount)\n");
};
return $labcount
}# mergestreamsb
#<!-- end tag aso -->
#<!-- start tag vbt -->
#
sub vbtb1 {# setup the binding for vbt binder
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("vbtb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {vbot});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - can cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("vbtbx ret ($labcount)\n");
};
return $labcount
}# vbtb
#<!-- start tag sca -->
#<!-- start tag dli -->
#<!-- start tag aso -->
#
sub iinitiators1 {# setup the labels for complex initiator signaling
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static, $strategy)=@_;
my ($labcount, $i);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("iinitiators1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {$strategy});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
for ($i = $Awfif::codelet-> {l} [$myli][21]; $i != $Awfif::codelet-> {l} [$myli][22];$i = trwsoadr ($i,1)) {
$labcount = labload (\@$lab, $labcount, wsbasetype ($i));
};#for
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));
$labcount = labload (\@$lab, $labcount, wsbasetype ($sti));
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("iinitiators1x ret ($labcount)\n");
};
return $labcount
}# iinitiators1
#
#<!-- end tag sca -->
#<!-- end tag dli -->
#<!-- end tag vbt -->
#
sub mergestreamsi1 {# setup the labels for mergestreams assert case resolution
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (iinitiators1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'mergestreams'));
}# mergestreamsi1
#
#<!-- start tag vbt -->
#
sub vbti1 {# setup the labels for vbt initiator signaling
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (iinitiators1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'vbt'));
}# vbti1
#
#<!-- end tag vbt -->
#
sub mstracasetestpi1 {# setup the labels for mergestreams case test resolution
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("mstracasetestpi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {mergestreams});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {case});
$labcount = labload (\@$lab, $labcount, wsbasetype ($sti));
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("mstracasetestpi1x ret ($labcount)\n");
};
return $labcount
}# mstracasetestpi1
#
sub mstraresctestpi1 {# setup the labels for mergestreams case test resolution
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("mstraresctestpi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {mergestreams});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {deploy});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {case});
$labcount = labload (\@$lab, $labcount, wsbasetype ($sti));
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("mstraresctestpi1x ret ($labcount)\n");
};
return $labcount
}# mstraresctestpi1
#
sub mstranoctestpi1 {# setup the labels for mergestreams case test resolution
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("mstranoctestpi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {mergestreams});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {statementcomplete});
$labcount = labload (\@$lab, $labcount, wsbasetype ($sti));
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("mstranoctestpi1x ret ($labcount)\n");
};
return $labcount
}# mstranoctestpi1
#
sub mstrarescinitpi1 {# setup the labels for initialisation of mergestreams case test resolution
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("mstrarescinitpi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {mergestreams});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {initialise});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {deploy});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {case});
$labcount = labload (\@$lab, $labcount, wsbasetype ($sti));
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("mstrarescinitpi1x ret ($labcount)\n");
};
return $labcount
}# mstrarescinitpi1
#<!-- start tag scs -->
#
sub pdcasappi1 {# setup the labels for initpdca signalling of application
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount, $i);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("pdcasappi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][21]));
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {deploy});
for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 2); $i != trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2);$i = trwsoadr ($i,1)) {
$labcount = labload (\@$lab, $labcount, wsbasetype ($i));
};#for
$labcount = labload (\@$lab, $labcount, wsbasetype (trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2)));
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
my ($pr);
for ($i = 1; $i <= $labcount; $i++) {
$pr = '<' . $Awfif::memes-> {snnih} {$$lab[$i]} . '>';
print ("$pr");
};#for
print ("pdcasappi1x ret ($labcount)\n");
};
return $labcount
}# pdcasappi1
#
sub pdcab1 {# setup the binding for Shewhart binder
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("pdcab1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {pdca});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - can cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("pdcabx ret ($labcount)\n");
};
return $labcount
}# pdcab
#
sub e2finhibb1 {# setup the binding for e2finhib binder
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("e2finhibb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {inhibitor});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - can cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("e2finhibbx ret ($labcount)\n");
};
return $labcount
}# e2finhibb
#
#<!-- end tag scs -->
#
sub comparest1 {# setup the labels for comparison of source and target
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("comparest1 myli $myli sti $sti ");
if (defined ($kwp)) {
print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};#if
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][21]));
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {source});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {target});
$labcount = labload (\@$lab, $labcount, wsbasetype (trwsoadr ($Awfif::codelet-> {l} [$myli][22], -1)));
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("comparest1x ret ($labcount)\n");
};
return $labcount
}# comparest1
# self1 does not appear to be used
sub self1 {# setup the labels for self analysis
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount, $i);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("self1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
for ($i = $Awfif::codelet-> {l} [$myli][21]; $i != $Awfif::codelet-> {l} [$myli][22];$i = trwsoadr ($i,1)) {
$labcount = labload (\@$lab, $labcount, wsbasetype ($i));
};#for
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
my ($pr);
for ($i = 1; $i <= $labcount; $i++) {
$pr = '<' . $Awfif::memes-> {snnih} {$$lab[$i]} . '>';
print ("$pr");
};#for
print ("selfx ret ($labcount)\n");
};
return $labcount
}# self1
#
#<!-- start tag scs -->
#
sub ecyclino1 {# setup the labels for e cyclin signalling
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount, $i);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("ecyclino1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][21]));
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {program});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {do});
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
my ($pr);
for ($i = 1; $i <= $labcount; $i++) {
$pr = '<' . $Awfif::memes-> {snnih} {$$lab[$i]} . '>';
print ("$pr");
};#for
print ("ecyclino1x ret ($labcount)\n");
};
return $labcount
}# ecyclino1
#
sub acyclino1 {# setup the labels for a cyclin signalling
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount, $i);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("acyclino1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][21]));
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {program});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {check});
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
my ($pr);
for ($i = 1; $i <= $labcount; $i++) {
$pr = '<' . $Awfif::memes-> {snnih} {$$lab[$i]} . '>';
print ("$pr");
};#for
print ("acyclino1x ret ($labcount)\n");
};
return $labcount
}# acyclino1
#
sub bcyclino1 {# setup the labels for b cyclin signalling
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount, $i);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("bcyclino1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][21]));
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {program});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {act});
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
my ($pr);
for ($i = 1; $i <= $labcount; $i++) {
$pr = '<' . $Awfif::memes-> {snnih} {$$lab[$i]} . '>';
print ("$pr");
};#for
print ("bcyclino1x ret ($labcount)\n");
};
return $labcount
}# bcyclino1
#
sub dcyclino1 {# setup the labels for d cyclin signalling
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount, $i);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("dcyclino1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][21]));
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {program});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {initiate});
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
my ($pr);
for ($i = 1; $i <= $labcount; $i++) {
$pr = '<' . $Awfif::memes-> {snnih} {$$lab[$i]} . '>';
print ("$pr");
};#for
print ("dcyclino1x ret ($labcount)\n");
};
return $labcount
}# dcyclino1
#
sub imemb1 {# setup the binding for internal membrane binder
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("imemeb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {membrane});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {internal});
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("imembx ret ($labcount)\n");
};
return $labcount
}# imemb
#
sub tfactorb1 {# setup the binding for tfactor binder
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("tfactorb myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {transcription});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {factor});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - can cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("tfactorbx ret ($labcount)\n");
};
return $labcount
}# tfactorb
#<!-- end tag scs -->
#<!-- end tag aso -->
#<!-- start tag sir -->
#
sub receptorb1 {# setup the binding for resolved assert receptor buffer binder
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount, $cwsbi, $i);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("receptorb myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
# updated for merged workspaces
$cwsbi = $Awfif::memes-> {currentwsbi};
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {signal});
$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 4);
$i != $Awfif::codelet-> {l} [$myli][22];
$i = trwsoadr ($i,1)) {
$labcount = labload (\@$lab, $labcount, wsbasetype ($i));
};#for
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
if (defined ($$static)) {
$$static = '';#can not depend on this being the same every return - can't cache
};#if
$Awfif::memes-> {currentwsbi} = $cwsbi;
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("receptorbx ret ($labcount)\n");
};
return $labcount
}# receptorb
#
sub receptorbi1 {# setup the binding for resolved assert receptor buffer binder
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount, $cwsbi, $i);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("receptorbi myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
# updated for merged workspaces
$cwsbi = $Awfif::memes-> {currentwsbi};
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {signal});
$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 5);
$i != $Awfif::codelet-> {l} [$myli][22];
$i = trwsoadr ($i,1)) {
$labcount = labload (\@$lab, $labcount, wsbasetype ($i));
};#for
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
if (defined ($$static)) {
$$static = '';#can not depend on this being the same every return - can't cache
};#if
$Awfif::memes-> {currentwsbi} = $cwsbi;
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("receptorbix ret ($labcount)\n");
};
return $labcount
}# receptorbi
#
sub receptorh1 {# setup the binding for receptor hierarchy signal schematic workspace binder
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("receptorh1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {signal});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - can cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("receptorhx ret ($labcount)\n");
};
return $labcount
}# receptorh
#<!-- end tag sir -->
#<!-- start tag cr -resweb -->
#
sub subpc1 {# setup the labels for subprogram indirect context
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount, $i, $cwsbi);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("subpc1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$cwsbi = $Awfif::memes-> {currentwsbi};
$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
for ($i = trwsoadr($Awfif::codelet-> {l} [$myli][21],2);
$i != trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2);
$i = trwsoadr ($i,1)) {
$labcount = labload (\@$lab, $labcount, wsbasetype ($i));
};#for
$labcount = labload (\@$lab, $labcount, wsbasetype (trwsoadr ($Awfif::codelet-> {l} [$myli][22],-2)));
if ($Awfif::codelet-> {l} [$myli] [36] == 0) {
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {subprogram});
};#else
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
$Awfif::memes-> {currentwsbi} = $cwsbi;
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("subpc1x ret ($labcount)\n");
};
return $labcount
}# subpc1
#<!-- start tag sca -->
#
sub hdob1 {# setup the binding for hdo binder
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("hdob1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {hdo});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - can cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("hdobx ret ($labcount)\n");
};
return $labcount
}# hdob
# hdoi1 does not appear to be used
sub hdoi1 {# setup the labels for hdo initiator signaling
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (iinitiators1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 'hdo'));
}# hdoi1
#
#<!-- start tag aso -->
#
sub msadoboppi1 {# setup the labels for hdo integration
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount, $i, $cwsbi);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("msadoboppi1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$cwsbi = $Awfif::memes-> {currentwsbi};
$Awfif::memes-> {currentwsbi} = $Awfif::codelet-> {l} [$myli] [20];
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {hdo});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
for ($i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 4);
$i != $Awfif::codelet-> {l} [$myli][22];
$i = trwsoadr ($i,1)) {
$labcount = labload (\@$lab, $labcount, wsbasetype ($i));
};#for
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));
$Awfif::memes-> {currentwsbi} = $cwsbi;
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("msadoboppi1x ret ($labcount)\n");
};
return $labcount
}# msadoboppi1
#
sub binderrc1 {# setup the labels for binder 4 to -1
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 1, 4));
}# binderrc1
#
sub bindercml1 {# setup the labels for binder 2 to -1
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
return (ibindervc1 ($myli, $sti, \@$lab, $kwp, $kwpr, \@$sactset, \$$static, 1));
}# bindercml1
#
#<!-- end tag aso -->
#<!-- end tag sca -->
#<!-- start tag vbt -->
#
sub vworldb1 {# setup the binding for vbot world workspace
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("vworldb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {square});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {naught});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - can cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("vworldbx ret ($labcount)\n");
};
return $labcount
}# vworldb
#
sub vwxstartb1 {# setup the binding for vbot world start workspace
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("vwxstartb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {wall});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {naught});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {one});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {two});
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - can cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("vwxstartbx ret ($labcount)\n");
};
return $labcount
}# vwxstartb
#
sub vcansb1 {# setup the binding for vbot can workspace
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("vcansb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {cans});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {naught});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - can cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("vcansbx ret ($labcount)\n");
};
return $labcount
}# vcansb
#
#<!-- end tag vbt -->
#<!-- start tag scl -->
#
sub pcellb1 {# setup the binding for pcell structural workspace
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("pcellb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {cans});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {naught});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - can cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("pcellbx ret ($labcount)\n");
};
return $labcount
}# pcellb
#
#<!-- end tag scl -->
#<!-- start tag scc -->
#<!-- start tag aso -->
#
sub warb1 {# setup the binding for wait and relay workspace
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("warb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {waitarelay});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - can cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("warbx ret ($labcount)\n");
};
return $labcount
}# warb
#
sub warasb1 {# setup the association for wait and relay operons
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("warasb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {waitarelay});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {qmark});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {qmark});
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - can cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("warasbx ret ($labcount)\n");
};
return $labcount
}# warasb
#
sub warmab1 {# match a wait and relay operon
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount, $lbuffer, $content);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("warmab1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {waitarelay});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
# now must find each <keyword> in $st1 snnh it into its index and labload it
$lbuffer = $sti;
while ($lbuffer =~ /<([\w]*)>/){
$content = $1;
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {$content});
$lbuffer =~ s/\Q<$1>/ /;
};#while
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - can cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("warmabx ret ($labcount)\n");
};
return $labcount
}# warmab
#
sub warmdob1 {# setup the association of do mergestreams with wait and relay operons
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("warmdob1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {waitarelay});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {do});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {mergestreams});
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - can cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("warmdobx ret ($labcount)\n");
};
return $labcount
}# warmdob
#
sub warhdob1 {# setup the association of histone do with wait and relay operons
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("warhdob1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {waitarelay});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {hdo});
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - can cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("warhdobx ret ($labcount)\n");
};
return $labcount
}# warhdob
#
sub warmsb1 {# setup the association of mergestreams stream with wait and relay operons
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("warmsb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {waitarelay});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {mergestreams});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {stream});
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - can cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("warmsbx ret ($labcount)\n");
};
return $labcount
}# warmsb
#
sub comparestb1 {# setup the binding for compare source target binder
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("comparestb1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {source});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {target});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {sequence});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {integration});
if (defined ($$static)) {
$$static = 't';#can depend on this being the same every return - can cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("comparestbx ret ($labcount)\n");
};
return $labcount
}# comparestb
#
sub comparesti1 {# setup the labels for compare source target
my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
my ($labcount, $i);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("comparesti1 myli $myli sti $sti kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
};
# updated for merged workspaces
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {source});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {target});
$labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
for ($i = $Awfif::codelet-> {l} [$myli][21]; $i != $Awfif::codelet-> {l} [$myli][22];$i = trwsoadr ($i,1)) {
$labcount = labload (\@$lab, $labcount, wsbasetype ($i));
};#for
$labcount = labload (\@$lab, $labcount, wsbasetype ($Awfif::codelet-> {l} [$myli][22]));
$labcount = labload (\@$lab, $labcount, wsbasetype ($sti));
if (defined ($$static)) {
$$static = '';#can't depend on this being the same every return - don't cache
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("comparesti1x ret ($labcount)\n");
};
return $labcount
}# comparesti1
#
#<!-- end tag aso -->
#<!-- end tag scc -->
#
sub labinv1 {
my ($myli, $as, $ae, $ael, $sponsor, $lomatchs, $lola, $loconcs, $lostrts, $loends, $logb, $loge, $filstrategy) = @_;
my ($i, $i2, $label, $type, $ltype, $sigcount, $aer);
# inversion of group builder complete's label space code
#
# checked for merged workspaces
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("labinv1 myli $myli as $as ae $ae ");
if ($myli > 0) {
};
$label = '';
$ltype = '';
$i2 = 0;
$aer = '';
# labinv1nsu1
$i = trwsoadr ($as, 1);
while ((($ael && !$aer) or (!$ael && ($i != $ae))) && ( awsoadr ($i) != 0)) {
my($kwai, $akwai, $kws, $kwl, $slab);
if ($ael && ($i == $ae)) {
# sponsor is now stable can mark its position in group members wso
if ($sponsor ne '') {# if use defined here no work gets done???
if ((defined ($Awfif::wsol-> {l} [awsoadr ($i)] [ $Awfif::memes-> {wsogstart} ]))
&& ($Awfif::wsol-> {l} [awsoadr ($i)] [ $Awfif::memes-> {wsogstart} ] != 0)
&& ($Awfif::wsol-> {l} [awsoadr ($i)] [ $Awfif::memes-> {wsogstart} ] != $sponsor)
){
my ($ngcsponsor);
$ngcsponsor =
$Awfif::wsol-> {l}[awsoadr ($i)][ $Awfif::memes-> {wsogcsponsor}]; #*** submacrok ***#
if (($ngcsponsor != 0) && ($ngcsponsor != $sponsor)) {&break ()};
$Awfif::wsol-> {l}[awsoadr ($i)][ $Awfif::memes-> {wsogcsponsor}] = $sponsor;#*** submacrok ***#
$Awfif::wsol-> {l}[awsoadr ($i)][ $Awfif::memes-> {wsogcsponsored}] = $sponsor;#*** submacrok ***#
};#update sponsor if specified
$type = ' ' . wsbasetype ($i);
$slab = getwsost4 ($i);
if ((($type == $Awfif::memes-> {snnh} {mkeywords}) or ($type == $Awfif::memes-> {snnh} {mkeyworde})) && (mkwlabel (\$slab, \$kwai, \$akwai, \$kws, \$kwl)) && (!ismemetic ($akwai))) {
# labinv1m1
my ($sparam, $param, $param2);
$sparam = jhlmappl ($kws);
if ($sparam =~ /,/) {
while ($sparam =~ /(\d+)+(,)*/i) {
$param = $1;
$param2 = $2;
$sparam =~ s/$param$param2//;
$type = ' '.$param;
$label = $label.$type;
$$lostrts[$i2++] = $i;
};#while
};#if
$ltype = '';#no repeats on mkeyword
}
else {
if ($type eq ' '.wsbasetype ( trwsoadr ($i, 1))) {#note repeat
$type = '_' . wsbasetype ($i);
};#repeat
if ($ltype ne $type) {# ignore repeats
$label = $label.$type;
$$lostrts[$i2++] = $i;
};#build direct label
$ltype = $type;
};#else
$i = trwsoadr ($i, 1);
};#for
# apply the linking function of group completion
# if the groups labels result in a match with a signal then raise the signal
#
$sigcount = msublabel1 ($myli, \$label, \@$lomatchs, \@$lola, \@$loconcs, \@$lostrts, \@$loends, \@$logb, \@$loge, $filstrategy);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("labinv1x ret $sigcount\n");
};
return $sigcount
}# labinv1
#
sub labload {
my ($lab, $labcount, $concept) = @_;
my ($count);
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
my ($pr);
$pr = $Awfif::memes-> {snnih}{$concept};
print ("labload labcount $labcount concept $pr($concept) ");
};
$count = $labcount + 1;
$$lab [$count] = $concept;
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("labloadx ret $count\n");
};
return $count
}# labload
#
#
sub destructionscout1 {
my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
my ($cdn, $cdnx, $descid);
#
# checked for merged workspaces
$cdn = clogstat (\$cdnx);
if (($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) && ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry})) {
print ("$cdn myli $myli ");
&itcpoutput ($myli);
};
# destruction codelets must use the full workspace
# see if this workspace has any telomeric structures to evaluate
if ((($descid = findtelhd ($Awfif::memes-> {currentwsbi}))>0)
&& (($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi}) > 0)
) {
# if the telomeric list has entries call in an evaluator
$Awfif::clp = ();
$Awfif::clp-> {log} = $Awfif::codelet-> {l} [$myli][13];
$Awfif::clp-> {urgency} = $Awfif::memes-> {parteu};
if (defined ($Awfif::codelet-> {l}[$myli][19])) {
$Awfif::clp-> {wsi} = $Awfif::codelet-> {l}[$myli][19];
}#wsi set
else {
$Awfif::clp-> {wsi} = $Awfif::memes-> {currentwsbi};
};
$Awfif::clp-> {strategy} = "destructionevaluator";
&cdsubmitcodelet ($myli, \$Awfif::clp);
};# got a telomere
if (($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) && ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry})) {
&clogstatx ();
}# destructionscout1
#
sub destructionevaluator1 {
my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
my ($count, $telcount,
$cdn, $cdnx);
#
# checked for merged workspaces
$cdn = clogstat (\$cdnx);
if (($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) && ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry})) {
print ("$cdn myli $myli ");
&itcpoutput ($myli);
};
# see if this workspace has any telomeric structures to evaluate
$count = 0;
$count = counttelst1 ($Awfif::memes-> {currentwsbi}, \$telcount);
if ($count > $Awfif::memes-> {telcountth}) {
$Awfif::clp = ();
$Awfif::clp-> {log} = $Awfif::codelet-> {l} [$myli][13];
$Awfif::clp-> {urgency} = ($Awfif::codelet-> {l} [$myli][3] * $Awfif::memes-> {blaunchm});
if (defined ($Awfif::codelet-> {l}[$myli][19])) {
$Awfif::clp-> {wsi} = $Awfif::codelet-> {l}[$myli][19];
}#wsi set
else {
$Awfif::clp-> {wsi} = $Awfif::memes-> {currentwsbi};
};
$Awfif::clp-> {strategy} = "destructionbuilder";
&cdsubmitcodelet ($myli, \$Awfif::clp);
};#if
if (($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) && ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry})) {
&clogstatx ();
}# destructionevaluator1
#
sub counttelst1 {
my ($ws, $telcount) = @_;
my ($ni, $descid, $count);
#
# checked for merged workspaces
# if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
# print ("counttelst1 ws $ws ");
# };
# see if this workspace has any telomeric structures to evaluate
$count = 0;
$$telcount = 0;
if ((($descid = findtelhd ($ws))>0)
&& (($ni = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi})) > 0)
) {
# countteljhlsu1
};#got telomeric structures to evaluate
# if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
# print ("counttelst1x telcount $$telcount ret ($count)\n");
# };
return $count
}# counttelst1
#
sub istelwso {
my ($ni, $count, $telcount) = @_;
my ($descid, $found, $life, $jhlsoi, $ini);
#
# see if this wso is telomeric and measure it
$found = '';
$ini = $$ni;
if ($$ni != 0) {
if ($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) {
print ("istelwso ni $$ni count $$count telcount $$telcount \n");
&itwsoutput ( trwsoadr ($$ni,1), $$ni);
};#if trace
$descid = $Awfif::wsol-> {l} [awsoadr ($$ni)] [2];
$$ni = 0;
while (($descid != 0)) {#search ni for telomeric descriptors
if (($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {value}) && ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})) {
$life = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi});
if ($life < $Awfif::memes-> {tellifeth} ) {
if (($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {lhead}) && ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})) {
$$ni = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi});
$$telcount ++;
$found = 't';
};# found a head
# isteljhlsu1
if (
($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {jhlsoi})
&& ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})
&& (($Awfif::jhls-> {l} [($jhlsoi = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi}))] [14] [2]) <= 1)
) {
$$count--;
};# telomere is last link to sponsor gc
# isteldoku1
if (
($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {destroyok})
&& ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})
&& (($Awfif::jhls-> {l} [($jhlsoi = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi}))] [14] [2]) <= 1)
&& (!telisie ($ini))
) {
$$count++;
};# telomere is allowed to be destroyed
$descid = $Awfif::workspace-> {l} [$descid] [0];
};#while
};#if
if ($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) {
print ("istelwsox nextni $$ni destcount $$count telcount $$telcount ret ($found)\n");
};
return $found
}# istelwso
#
sub writeiecok {
my ($sponsor) = @_;
my ($iedesc, $found, $jhlsi);
#
# see if conditions exist to write to the independent & equivalent cache
if ($sponsor != 0) {
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("writeiecok sponsor $sponsor \n");
&itwsoutput ( trwsoadr ($sponsor,1), $sponsor);
};#if trace
if ( (($iedesc = findtdesc ($Awfif::wsol-> {l} [ awsoadr ($sponsor)] [2], $Awfif::memes-> {snnh} {indequiv})) == 0 ) #groupbuilder has not previously written the cache details
&& (($iedesc = findtdesc ($Awfif::wsol-> {l} [ awsoadr( trwsoadr($sponsor, -1))] [2], $Awfif::memes-> {snnh} {mindequiv})) != 0 ) #groupbuilder has not previously written the cache details
&& (($jhlsi = ($Awfif::workspace-> {l} [$iedesc][2] - $Awfif::memes-> {snnh} {wsi})) != 0)
&& ($Awfif::jhls-> {l} [$jhlsi][15] [0])
){
$found = 't';
};#if conditions ok
};#if
if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
print ("writeiecokx ret ($found)\n");
};
return $found
}# writeiecok
#
sub telhasiecache {
my ($ni) = @_;
my ($iedesc, $found, $jhlsi);
#
# see if telomere has an ie cache
if ($ni != 0) {
if ($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) {
print ("telhasiecache ni $ni \n");
&itwsoutput ( trwsoadr ($ni,1), $ni);
};#if trace
if ( (($iedesc = findtdesc ($Awfif::wsol-> {l} [ awsoadr ($ni)] [2], $Awfif::memes-> {snnh} {mindequiv})) != 0 ) #groupbuilder has not previously written the cache details
&& (($jhlsi = ($Awfif::workspace-> {l} [$iedesc][2] - $Awfif::memes-> {snnh} {wsi})) != 0)
&& ($Awfif::jhls-> {l} [$jhlsi][15][2] > 0)
&& ($Awfif::jhls-> {l} [$Awfif::jhls-> {l} [$jhlsi][15][2]][15][1])
){
$found = 't';
};#if conditions ok
};#if
if ($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) {
print ("telhasiecachex ret ($found)\n");
};
return $found
}# telhasiecache
#
sub telisie {
my ($ni) = @_;
my ($iedesc, $found, $jhlsi);
#
# see if this telomere is an i.e. master
if ($ni != 0) {
if ($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) {
print ("telisie ni $ni \n");
&itwsoutput ( trwsoadr ($ni,1), $ni);
};#if trace
if ( (($iedesc = findtdesc ($Awfif::wsol-> {l} [ awsoadr ($ni)] [2], $Awfif::memes-> {snnh} {mindequiv})) != 0 ) #groupbuilder has not previously written the cache details
&& (($jhlsi = ($Awfif::workspace-> {l} [$iedesc][2] - $Awfif::memes-> {snnh} {wsi})) != 0)
&& ($Awfif::jhls-> {l} [$jhlsi][15][3] > 0)
){
$found = 't';
};#if conditions ok
};#if
if ($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) {
print ("telisiex ret ($found)\n");
};
#
sub teltail {
my ($wso) = @_;
my ($descid, $found, $result);
#
# given a telomere head wso find the tail reference
$found = '';
$result = 0;
if ($wso != 0) {
if ($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) {
print ("teltail wso $wso \n");
&itwsoutput ( $wso);
};#if trace
$descid = $Awfif::wsol-> {l} [awsoadr ($wso)] [2];
while (($descid != 0) && (!$found)) {#search ni for telomeric descriptors
if (
($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {ltail})
&& ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})
&& (($result = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi})) != 0)
) {
$found = 't';
};# telomere is allowed to be destroyed
$descid = $Awfif::workspace-> {l} [$descid] [0];
};#while
};#if
if ($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) {
print ("teltailx ret ($result)\n");
};
return $result
}# teltail
#
#
sub destructionbuilder1 {
my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
my ($ni, $descid, $found, $life, $count, $presentni, $lastni, $notdeleting, $cwsbi, $cdn, $cdnx);
#
# checked for merged workspaces
$cdn = clogstat (\$cdnx);
$cwsbi = $Awfif::memes-> {currentwsbi};
if (($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) && ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry})) {
print ("$cdn myli $myli ");
&itcpoutput ($myli);
};
# see if this workspace has any telomeric structures to destroy
$count = 0;
$presentni = 0;
$notdeleting = 't';
if ((($descid = findtelhd ($Awfif::memes-> {currentwsbi}))>0)
&& (($ni = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi})) > 0)
) {
while ($ni != 0) {
$descid = $Awfif::wsol-> {l} [awsoadr ($ni)] [2];
$found = '';
if ($notdeleting) {
$lastni = $presentni;
$presentni = $ni;
};#if
$ni = 0;
while (($descid != 0)) {#search ni for telomeric descriptors
if (($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {value}) && ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})) {
# destructionbtellu1
$life = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi});
if ($life < $Awfif::memes-> {tellifeth} ) {
$count++;
$found = 't';
};#if
}# found a count
if (($Awfif::workspace-> {l} [$descid] [3] == $Awfif::memes-> {snnh} {lhead}) && ($Awfif::workspace-> {l} [$descid] [4] == $Awfif::memes-> {snnh} {telomere})) {
$ni = ($Awfif::workspace-> {l} [$descid] [2] - $Awfif::memes-> {snnh} {wsi});
};# found a head
$descid = $Awfif::workspace-> {l} [$descid] [0];
};#while
# destructionbteldu1
if (($count > $Awfif::memes-> {telcountth}) && ($found) && ($ni != 0)) {# delete those older than count
$notdeleting = '';
$skipdel = '';
if (($nextni = freetelstr ($ni, $presentni, \$skipdel)) == 0) {
elsif ($skipdel) {
# ni will be the next item to look at
else {
$ni = $presentni;
};#else
};#if
};#while ni != 0
};#got telomeric structures to destroy
$Awfif::memes-> {currentwsbi} = $cwsbi;
if (($Awfif::memes-> {telomeretrace} > $Awfif::memes-> {traceentry}) && ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry})) {
&clogstatx ();
}# destructionbuilder1
#
 Politics, Economics & Evolutionary Psychology |
Business Physics Nature and nurture drive the business eco-system Human nature Emerging structure and dynamic forces of adaptation |
 |
integrating quality appropriate for each market |
|
 |