ARSperl
view release on metacpan or search on metacpan
ars_GetSessionConfiguration
ars_SetOverlayGroup ars_SwitchToBestPracticeMode ars_SwitchToBaseMode
);
$ARS::VERSION = '2.00';
$ARS::DEBUGGING = 0;
$ARS::logging_file_ptr = 0;
# definitions required for backwards compatibility
if (!defined &ARS::AR_IMPORT_OPT_CREATE) {
eval 'sub AR_IMPORT_OPT_CREATE { 0; }';
}
if (!defined &ARS::AR_IMPORT_OPT_OVERWRITE) {
eval 'sub AR_IMPORT_OPT_OVERWRITE { 1; }';
}
bootstrap ARS $ARS::VERSION;
#if AR_EXPORT_VERSION >= 4
/* build entryList */
ret = perl_BuildEntryList(ctrl, &entryList, entry_id);
if(ret)
goto get_entryblob_end;
switch(locType) {
case AR_LOC_FILENAME:
if(locFile == NULL) {
ARError_add(AR_RETURN_ERROR,
AP_ERR_USAGE,
"locFile parameter required when specifying AR_LOC_FILENAME");
goto get_entryblob_end;
}
loc.locType = AR_LOC_FILENAME;
loc.u.filename = strdup(locFile); /* strdup(locFile) ? i'm not completely sure
which to use. will FreeARLocStruct call
free(loc.locType)? i'm assuming it will.
Purify doesnt complain, so i'm going
to leave this alone. */
break;
case AR_LOC_BUFFER:
loc.locType = AR_LOC_BUFFER;
loc.u.buf.bufSize = 0;
break;
default:
ARError_add(AR_RETURN_ERROR,
AP_ERR_USAGE,
"locType parameter is required.");
goto get_entryblob_end;
break;
}
ret = ARGetEntryBLOB(ctrl, schema, &entryList, field_id,
&loc, &status);
if(!ARError(ret, status)) {
if(locType == AR_LOC_BUFFER)
#if PERL_PATCHLEVEL_IS >= 6
XPUSHs(sv_2mortal(newSVpvn((const char *)
loc.u.buf.buffer,
ARS/OOform.pm view on Meta::CPAN
sub new {
my ($class, $self) = (shift, {});
my ($b) = bless($self, $class);
my ($form, $vui, $connection) =
ARS::rearrange([FORM,VUI,CONNECTION],@_);
$connection->pushMessage(&ARS::AR_RETURN_ERROR,
81000,
"usage: new ARS::form(-form => name, -vui => vui, -connection => connection)\nform and connection parameters are required."
)
if(!defined($form) || !defined($connection));
$vui = "Default Admin View" unless defined $vui;
$self->{'form'} = $form;
$self->{'connection'} = $connection;
$self->{'vui'} = $vui;
my %f = ARS::ars_GetFieldTable($connection->{'ctrl'},
$form);
ARS/OOform.pm view on Meta::CPAN
}
# getFieldID(-field => name)
sub getFieldID {
my $this = shift;
my ($name) = ARS::rearrange([FIELD], @_);
$this->{'connection'}->pushMessage(&ARS::AR_RETURN_ERROR,
81000,
"usage: form->getFieldID(-field => name)\nname parameter is required.")
unless defined($name);
if(!defined($this->{'fields'}->{$name})) {
$this->{'connection'}->pushMessage(&ARS::AR_RETURN_ERROR,
81001,
"field '$name' not in view: ".$this->{'vui'}."\n"
);
}
return $this->{'fields'}->{$name} if(defined($name));
}
# getFieldName(-id => id)
sub getFieldName {
my $this = shift;
my ($id) = ARS::rearrange([ID], @_);
$this->{'connection'}->pushMessage(&ARS::AR_RETURN_ERROR,
81000,
"usage: form->getFieldName(-id => id)\nid parameter required."
)
unless defined($id);
return $this->{'fields_rev'}->{$id} if defined($this->{'fields_rev'}->{$id});
$this->{'connection'}->pushMessage(&ARS::AR_RETURN_ERROR,
81002,
"field id '$id' not available on form: ".$this->{'form'}.""
);
}
ARS/OOform.pm view on Meta::CPAN
}
# delete(-entry => id)
sub delete {
my $this = shift;
my ($id) = ARS::rearrange([ENTRY],@_);
$this->{'connection'}->pushMessage(&ARS::AR_RETURN_ERROR,
81000,
"usage: form->delete(-entry => id)\nentry parameter is required.")
unless defined($id);
my (@d);
# allow the user to delete multiple entries in one shot
if(ref($id) eq "ARRAY") {
@d = @{$id};
} else {
push @d, $id;
ARS/OOform.pm view on Meta::CPAN
# merge(-type => mergeType, -values => { field1 => value1, ... })
sub merge {
my ($this) = shift;
my ($type, $vals) =
ARS::rearrange([TYPE,[VALUE,VALUES]],@_);
$this->{'connection'}->pushMessage(&ARS::AR_RETURN_ERROR,
81000,
"usage: form->merge(-type => mergeType, -values => { field1 => value1, ... })\ntype and values parameters are required.")
unless(defined($type) && defined($vals));
$this->{'connection'}->pushMessage(&ARS::AR_RETURN_ERROR,
81000,
"usage: form->merge(-type => mergeType, -values => { field1 => value1, ... })\nvalues parameter must be HASH ref.")
unless ref($vals) eq "HASH";
my (%realmap);
# as we work thru each value, we need to perform translations for
ARS/OOform.pm view on Meta::CPAN
sub set {
my ($this) = shift;
my ($entry,$gettime,$vals) =
ARS::rearrange([ENTRY,GETTIME,[VALUE,VALUES]],@_);
$gettime = 0 unless defined($gettime);
$this->{'connection'}->pushMessage(&ARS::AR_RETURN_ERROR,
81000,
"usage: form->set(-entry => id, -gettime => tstamp, -values => { field1 => value1, ... })\nentry and values parameters are required."
)
unless (defined($vals) && defined($entry));
$this->{'connection'}->pushMessage(&ARS::AR_RETURN_ERROR,
81000,
"usage: form->set(-entry => id, -values => { field1 => value1, ... })\nvalues parameter must be HASH ref.")
unless ref($vals) eq "HASH";
my (%realmap);
ARS/OOform.pm view on Meta::CPAN
}
# value2internal(-field => name, -value => value)
sub value2internal {
my ($this) = shift;
my ($f, $v) = ARS::rearrange([FIELD,VALUE], @_);
$this->{'connection'}->pushMessage(&ARS::AR_RETURN_ERROR,
81000,
"usage: form->value2internal(-field => name, -value => value)\nfield parameter is required.")
unless (defined($f));
return $v unless defined $v;
my ($t) = $this->getFieldType($f);
print "value2internal($f, $v) type=$t\n"
if $this->{'connection'}->{'.debug'};
# translate an text value into an enumeration number if this
# field is an enumeration field and we havent been passed a number
ARS/OOform.pm view on Meta::CPAN
}
# internal2value(-field => name, -id => id, -value => value)
sub internal2value {
my ($this) = shift;
my ($f, $id, $v) = ARS::rearrange([FIELD,ID,VALUE], @_);
$this->{'connection'}->pushMessage(&ARS::AR_RETURN_ERROR,
81000,
"usage: form->internal2value(-field => name, -id => id, -value => value)\nid or field parameter are required.")
unless (defined($f) || defined($id));
$f = $this->getFieldName(-id => $id) unless defined($f);
my ($t) = $this->getFieldType($f);
print "internal2value($f, $v) type=$t\n"
if $this->{'connection'}->{'.debug'};
# translate an enumeration value into a text value
ARS/OOform.pm view on Meta::CPAN
}
# create(-values => { field1 => value1, ... })
sub create {
my ($this) = shift;
my ($vals) = ARS::rearrange([[VALUES,VALUE]],@_);
$this->{'connection'}->pushMessage(&ARS::AR_RETURN_ERROR,
81000,
"usage: form->create(-values => { field1 => value1, ... })\nvalues parameter is required.")
unless defined($vals);
$this->{'connection'}->pushMessage(&ARS::AR_RETURN_ERROR,
81000,
"usage: form->create(-values => { field1 => value1, ... })\nvalues parameter must be HASH ref.")
unless ref($vals) eq "HASH";
my (%realmap);
print "Mapping field information.\n" if $self->{'connection'}->{'.debug'};
ARS/OOform.pm view on Meta::CPAN
}
# get(-entry => entryid, -fields => [ field1, field2 ])
sub get {
my $this = shift;
my ($eid, $fields) = ARS::rearrange([ENTRY,[FIELD,FIELDS]],@_);
$this->{'connection'}->pushMessage(&ARS::AR_RETURN_ERROR,
81000,
"usage: form->get(-entry => entryid, -fields => [ field1, field2, ... ])\nentry parameter is required.")
unless defined($eid);
my (@fieldlist) = ();
my ($allfields) = 1;
if(defined($fields)) {
$allfields = 0;
foreach (@{$fields}) {
push @fieldlist, $this->getFieldID($_);
}
ARS/OOform.pm view on Meta::CPAN
# getAsHash(-entry => entryid, -fields => [field1, field2, ...])
sub getAsHash {
my $this = shift;
my ($eid, $fields) = ARS::rearrange([ENTRY,[FIELD,FIELDS]],@_);
$this->{'connection'}->pushMessage(&ARS::AR_RETURN_ERROR,
81000,
"usage: form->getAsHash(-entry => entryid, -fields => [ field1, field2, ... ])\nentry parameter is required.")
unless defined($eid);
my (@fieldlist) = ();
my ($allfields) = 1;
if(defined($fields)) {
$allfields = 0;
foreach (@{$fields}) {
push @fieldlist, $this->getFieldID($_);
}
ARS/OOform.pm view on Meta::CPAN
# getAttachment(-entry => eid, -field => fieldname, -file => filename)
# if file isnt specified, the attachment is returned "in core"
sub getAttachment {
my $this = shift;
my ($eid, $field, $file) = ARS::rearrange([ENTRY,FIELD,FILE],@_);
if(!defined($eid) && !defined($field)) {
$this->{'connection'}->pushMessage(&ARS::AR_RETURN_ERROR,
81000,
"usage: getAttachment(-entry => eid, -field => fieldname, -file => filename)\nentry and field parameters are required.");
}
if(defined($file)) {
my $rv = ARS::ars_GetEntryBLOB($this->{'connection'}->{'ctrl'},
$this->{'form'},
$eid,
$this->getFieldID($field),
ARS::AR_LOC_FILENAME,
$file);
$this->{'connection'}->tryCatch();
ARS/OOsup.pm view on Meta::CPAN
$schemaType, undef,
$name);
}
sub openForm {
my $this = shift;
my($form, $vui) = rearrange([FORM,VUI], @_);
$this->pushMessage(&ARS::AR_RETURN_ERROR,
81000,
"usage: c->openForm(-form => name, -vui => vui)\nform parameter is required.")
if(!defined($form) || ($form eq ""));
$this->tryCatch();
return new ARS::form(-form => $form,
-vui => $vui,
-connection => $this);
}
1;
of the Copyright Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or
copyrights for the package.
"You" is you, if you're thinking about copying or distributing
this Package.
"Reasonable copying fee" is whatever you can justify on the
basis of media cost, duplication charges, time of people involved,
and so on. (You will not be required to justify it to the
Copyright Holder, but only to the computing community at large
as a market that must bear the fee.)
"Freely Available" means that no fee is charged for the item
itself, though there may be fees involved in handling the item.
It also means that recipients of the item may redistribute it
under the same conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that you
ARS 5.x APIs, the ars_NT* functions (notifier library) will no longer
work. The notifier system has completely changed in release 5.0 of
ARsystem.
Regardless of what version of API you compile against, the following
functions have had their parameters altered which means that scripts
will need to be editted (unless you are using the OO layer).
Function What's Changed
--------------------------------------------------------------
ars_GetListEntry additional required parameter
ars_GetListEntryWithFields additional required parameter
The following functions have altered return values.
Function What's Changed
--------------------------------------------------------------
ars_GetCharMenu for query menus, the
labelField is no longer
a scalar. it's now an
array ref.
----------
The 1.62 release includes ARS 4.0 integration. There are a few things
that have changed regardless of what version of ARS you compile against
and there are things that have changed only if you are compiling against
v4.0 (or greater).
First, regardless of what version of ARS you are compiling this against,
ars_perl_qualifier now takes a control struct (in addition to the
encoded qualifier). When compiled against pre-4.0 APIs, the control struct
parameter is still required, but is ignored. IF YOU USE THIS ROUTINE IN
EXISTING SCRIPTS, THEY WILL NEED TO BE CHANGED.
Previously, when perl executed "use ARS;" it would automatically trigger a
call to ARS::__ars_init(). This routine was im`ortant for setting up
system specific stuff as well as preparing to connect to a private
server. Now this routine is part of ars_Login() because, as of 4.0, we need
the control structure that ars_Login() generates in order to call
ARInitialization (a.k.a. __ars_init). The __ars_init() routine is still
there and is callable, but doesn't do anything if you compile against ARS>=4.0
example/ars_QualDecode.pl view on Meta::CPAN
#
# $Header: /cvsroot/arsperl/ARSperl/example/ars_QualDecode.pl,v 1.7 2000/06/01 16:54:03 jcmurphy Exp $
#
# MODULE
# ars_QualDecode.pl
#
# DESCRIPTION
# this module is designed to be "required" by another
# perl script (your script). it includes a routine
# and some helpers. the only only you need to
# be concerned with is Decode_QualHash.
#
# AUTHOR
# jeff murphy
#
# $Log: ars_QualDecode.pl,v $
# Revision 1.7 2000/06/01 16:54:03 jcmurphy
# *** empty log message ***
html/copying.html view on Meta::CPAN
<dt>c)
<dd>If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)<p>
</dl>
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
html/copying.html view on Meta::CPAN
<dt>4.
<dd>You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.<p>
<dt>5.
<dd>You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.<p>
<dt>6.
<dd>Each time you redistribute the Program (or any work based on the
html/install.html view on Meta::CPAN
<LI> Type "make"
<LI> Type "make install" (may require special permission). This will
install the perl extension into the perl lib directory.
<LI> Try one of the example scripts.
</OL>
<H2> Notes </H2>
HPUX users may need to compile the extension statically into the Perl binary.
<B>Windows users</B> can use the <I>pre-compiled binary distribution</I> along with ActiveState Perl. <a href="http://developer.bmc.com/communities/docs/DOC-5262">Check here</a> (free registration required) for precompiled ActiveState PPD files.
</BODY>
</HTML>
html/manual/ars_MergeEntry.html view on Meta::CPAN
} else {
arsdie("MergeEntry $RPTID $ret") if $ars_errstr;
print "$RPTID replaced\n";
}
}
</PRE>
Note the value "3075" for mergeType. That translates to<P>
<PRE>
2048: skip field pattern checking
1024: allow NULL in required fields
+ 3: delete existing entry and create new in its place
-------
3075
</PRE>
<P>
<DL>
<DT><B>On success</B><DD>
If a NEW entry was created: returns the entry-id of the merged entry.<BR>
If an EXISTING entry was over-written: returns "" and <code>$ars_errstr</code> will be "" (or, more correctly, <code>%ARS::ars_errhash</code> will not contain any FATAL or ERROR messages - but might contains WARNINGs or NOTICEs). <BR>
html/manual/ars_MergeEntry.html view on Meta::CPAN
<TR>
<TD>3</TD><TD>Delete the existing entry and create a new on in its place</TD>
</TR>
<TR>
<TD>4</TD><TD>Update fields specified in the fieldlist in existing entry</TD>
</TR>
<TR>
<TD>5</TD><TD>Generate a new entry id for all entries</TD>
</TR>
<TR>
<TD>1024+num above</TD><TD>Allow NULL in required fields (not applicable for Submitter,
Status or Short-Description)</TD>
</TR>
<TR>
<TD>2048+num above</TD><TD>Skip field pattern checking</TD>
</TR>
<TR>
<TD>4096+num above</TD><TD>Ignore filter processing</TD>
</TR>
</TABLE>
<P>
html/manual/ars_padEntryid.html view on Meta::CPAN
<HTML>
<HEAD>
<TITLE>ARSperl Programmer's Manual</TITLE>
</HEAD>
<BODY BGCOLOR="#FFFFFF">
<H2><CODE>ars_padEntryid(ctrl, schema, entry_id)</CODE></H2>
Pads entry_id with the required number of zeroes.
<P>
<A HREF="toc.html"><IMG ALT="<--" SRC="arrow.gif" ALIGN=CENTER> Back to Table of Contents </A>
</BODY>
</HTML>
supportrev.c view on Meta::CPAN
* -1 on failure
* -2 on warning
*/
int
rev_ARInternalIdList(ARControlStruct * ctrl, HV * h, char *k, ARInternalIdList * il)
{
if (!il || !h || !k) {
ARError_add(AR_RETURN_ERROR, AP_ERR_GENERAL,
"rev_ARInternalIdList: required param is NULL");
return -1;
}
if (SvTYPE((SV *) h) == SVt_PVHV) {
if (hv_exists(h, k, strlen(k) )) {
SV **val = hv_fetch(h, k, strlen(k) , 0);
if (val && *val) {
/* hash value should be an array reference */
if (SvTYPE(SvRV(*val)) == SVt_PVAV) {
supportrev.c view on Meta::CPAN
/* make sure the hash contains the keys we need */
if (!(hv_exists(hr, "server", 6) &&
hv_exists(hr, "sqlCommand", 10) &&
hv_exists(hr, "valueIndex", 10) &&
hv_exists(hr, "noMatchOption", 13) &&
hv_exists(hr, "multiMatchOption", 16))) {
ARError_add(AR_RETURN_ERROR, AP_ERR_GENERAL,
"rev_ARAssignSQLStruct: required hash key not found");
return -1;
}
/* copy the key values into the buffer */
rv += strcpyHVal(hr, "server", s->server, AR_MAX_SERVER_SIZE);
/*
svp = hv_fetch(hr, "sqlCommand", strlen("sqlCommand") , 0);
SvPV(*svp, len);
*/
supportrev.c view on Meta::CPAN
if (rev_ARByteListStr2Type(ctrl, typeString, &(b->type)) == -1)
return -1;
b->numItems = byteLen;
b->bytes = MALLOCNN(byteLen + 1); /* don't want FreeAR..
* to whack us */
copymem(b->bytes, byteString, byteLen);
return 0;
}
} else {
ARError_add(AR_RETURN_ERROR, AP_ERR_GENERAL,
"rev_ARByteList: required keys (type and value) not found in inner hash.");
}
} else {
ARError_add(AR_RETURN_ERROR, AP_ERR_GENERAL,
"rev_ARByteList: hash value is not hash ref for key:");
ARError_add(AR_RETURN_ERROR, AP_ERR_CONTINUE,
k ? k : "[key null]");
printf( "SvTYPE = %d\n", SvTYPE(*hr) );
}
} else {
ARError_add(AR_RETURN_WARNING, AP_ERR_GENERAL,
supportrev.c view on Meta::CPAN
#if AR_EXPORT_VERSION >= 3
hv_exists(h, "noMatchOption", 13) &&
hv_exists(h, "multiMatchOption", 16) &&
#endif
(hv_exists(h, "fieldId", 7) ||
hv_exists(h, "currencyField", 13) ||
hv_exists(h, "statHistory", 11) ))
) {
ARError_add(AR_RETURN_ERROR, AP_ERR_GENERAL,
"rev_ARAssignFieldStruct_helper: required hash key not found");
return -1;
}
strcpyHVal(h, "server", m->server, AR_MAX_SERVER_SIZE);
strcpyHVal(h, "schema", m->schema, AR_MAX_NAME_SIZE);
if (hv_exists(h, "fieldId", 7)) {
m->tag = AR_FIELD;
if (ulongcpyHVal(h, "fieldId", &(m->u.fieldId)) != 0)
return -1;
} else if (hv_exists(h, "statHistory", 11)) {
supportrev.c view on Meta::CPAN
ARError_add(AR_RETURN_ERROR, AP_ERR_GENERAL,
"rev_ARStatHistoryValue: first argument is not a hash");
return -1;
}
static int
rev_ARStatHistoryValue_helper(ARControlStruct * ctrl, HV * h, ARStatHistoryValue * s)
{
if (!(hv_exists(h, "userOrTime", 10) && hv_exists(h, "enumVal", 7))) {
ARError_add(AR_RETURN_ERROR, AP_ERR_GENERAL,
"rev_ARAssignFieldStruct_helper: required hash key not found");
return -1;
}
if (ulongcpyHVal(h, "enumVal", &(s->enumVal)) != 0)
return -1;
if (uintcpyHVal(h, "userOrTime", &(s->userOrTime)) != 0)
return -1;
return 0;
}
supportrev.c view on Meta::CPAN
}
static int
rev_ARArithOpAssignStruct_helper(ARControlStruct * ctrl,
HV * h, ARArithOpAssignStruct * s)
{
SV **svp;
if (!hv_exists(h, "oper", 4)) {
ARError_add(AR_RETURN_ERROR, AP_ERR_GENERAL,
"rev_ARArithOpAssignStruct_helper: hash does not contain required key 'oper'.");
return -1;
}
/* decode the operation type */
svp = hv_fetch(h, "oper", strlen("oper") , 0);
if (svp && *svp) {
char *c = SvPV(*svp, PL_na);
if (rev_ARArithOpAssignStructStr2OP(ctrl, c, &(s->operation)) != 0)
return -1;
}
supportrev.c view on Meta::CPAN
else {
ARError_add(AR_RETURN_ERROR, AP_ERR_GENERAL,
"rev_ARArithOpAssignStructStr2OP: operation 'negate' ('-') requires 'left' key.");
return -1;
}
}
/* other operations require both left and right */
if (!(hv_exists(h, "left", 4) && hv_exists(h, "right", 5))) {
ARError_add(AR_RETURN_ERROR, AP_ERR_GENERAL,
"rev_ARArithOpAssignStruct_helper: 'left' AND 'right' keys are required.");
return -1;
}
if (rev_ARAssignStruct(ctrl, h, "left", &(s->operandLeft)) == -1)
return -1;
return rev_ARAssignStruct(ctrl, h, "right", &(s->operandRight));
}
static int
rev_ARArithOpAssignStructStr2OP(ARControlStruct * ctrl, char *c, unsigned int *o)
{
supportrev.c view on Meta::CPAN
hv_exists(h, "value", strlen("value") ) &&
hv_exists(h, "valueType", strlen("valueType") )) {
rv += ulongcpyHVal(h, "prop", &(m->props[idx].prop));
rv += rev_ARValueStruct(ctrl, h, "value", "valueType",
&(m->props[idx].value));
return rv;
}
ARError_add(AR_RETURN_ERROR, AP_ERR_GENERAL,
"rev_ARPropList_helper: required hash keys not present (prop, value, valueType).");
return -1;
}
#endif /* 3.x */
int
rev_ARActiveLinkMacroStruct(ARControlStruct * ctrl,
HV * h, char *k, ARActiveLinkMacroStruct * m)
{
if (!m || !h || !k) {
ARError_add(AR_RETURN_ERROR, AP_ERR_GENERAL,
supportrev.c view on Meta::CPAN
hv_exists(h, "macroText", strlen("macroText") ) &&
hv_exists(h, "macroName", strlen("macroName") )) {
rv += strcpyHVal(h, "macroName", m->macroName, AR_MAX_NAME_SIZE);
rv += strmakHVal(h, "macroText", &(m->macroText));
rv += rev_ARMacroParmList(ctrl, h, "macroParms", &(m->macroParms));
return 0;
}
ARError_add(AR_RETURN_ERROR, AP_ERR_GENERAL,
"rev_ARActiveLinkMacroStruct_helper: required keys not present in hash (macroParms, macroText, macroName)");
return -1;
}
int
rev_ARMacroParmList(ARControlStruct * ctrl, HV * h, char *k, ARMacroParmList * m)
{
if (!h || !k || !*k || !m) {
ARError_add(AR_RETURN_ERROR, AP_ERR_GENERAL,
"rev_ARMacroParmList: invalid parameter(s).");
return -1;
( run in 0.639 second using v1.01-cache-2.11-cpan-0a6323c29d9 )