void DestroyVars(int all)
{
int i;
Var *v, *next, *prev;
for (i=0; i<VAR_HASH_SIZE; i++) {
v = VHashTbl[i];
VHashTbl[i] = NULL;
prev = NULL;
while(v) {
if (all || !v->preserve) {
DestroyValue(v->v);
next = v->next;
free(v);
} else {
if (prev) prev->next = v;
else VHashTbl[i] = v;
prev = v;
next = v->next;
v->next = NULL;
}
v = next;
}
}
}
bool HLXSListTest::HandleFindCmd(const UTVector<UTString>& info)
{
bool ret = false;
int value = 0;
bool useCurrentPos = false;
if (!UTParamUtil::GetInt(info[1], value) ||
!UTParamUtil::GetBool(info[2], useCurrentPos))
{
DPRINTF(D_ERROR, ("npSList::HandleFindCmd : failed to convert parameter\n"));
}
else
{
LISTPOSITION pos = (useCurrentPos) ? m_pos : m_list.GetHeadPosition();
void* pValue = 0;
bool destroyValue = FindValue(value, pos, pValue);
if (useCurrentPos)
m_pos = m_list.Find(pValue, pos);
else
m_pos = m_list.Find(pValue);
if (destroyValue)
DestroyValue(pValue);
ret = true;
}
return ret;
}
/*!
* \brief Clears all the parameters
*/
void ParameterList::Clear()
{
for (auto it = m_parameters.begin(); it != m_parameters.end(); ++it)
DestroyValue(it->second);
m_parameters.clear();
}
/*!
* \brief Removes the parameter named `name`
*
* Search for a parameter named `name` and remove it from the parameter list, freeing up its memory
* Nothing is done if the parameter is not present in the parameter list
*
* \param name Name of the parameter
*/
void ParameterList::RemoveParameter(const String& name)
{
auto it = m_parameters.find(name);
if (it != m_parameters.end())
{
DestroyValue(it->second);
m_parameters.erase(it);
}
}
int SetVar(char const *str, Value *val)
{
Var *v = FindVar(str, 1);
if (!v) return E_NO_MEM; /* Only way FindVar can fail */
DestroyValue(v->v);
v->v = *val;
return OK;
}
/*!
* \brief Create an uninitialized value of a set name
*
* \param name Name of the parameter
* \param value Value of the parameter
*
* \remark The previous value if any gets destroyed
*/
ParameterList::Parameter& ParameterList::CreateValue(const String& name)
{
std::pair<ParameterMap::iterator, bool> pair = m_parameters.insert(std::make_pair(name, Parameter()));
Parameter& parameter = pair.first->second;
if (!pair.second)
DestroyValue(parameter);
return parameter;
}
static void DumpSysVar(char const *name, const SysVar *v)
{
char buffer[VAR_NAME_LEN+10];
if (name && !*name) name=NULL;
if (!v && !name) return; /* Shouldn't happen... */
buffer[0]='$'; buffer[1] = 0;
if (name) strcat(buffer, name); else strcat(buffer, v->name);
fprintf(ErrFp, "%*s ", VAR_NAME_LEN+1, buffer);
if (v) {
if (v->type == SPECIAL_TYPE) {
Value val;
SysVarFunc f = (SysVarFunc) v->value;
f(0, &val);
PrintValue(&val, ErrFp);
Putc('\n', ErrFp);
DestroyValue(val);
} else if (v->type == STR_TYPE) {
char const *s = *((char **)v->value);
int y;
Putc('"', ErrFp);
for (y=0; y<MAX_PRT_LEN && *s; y++) {
if (*s == '"') {
fprintf(ErrFp, "\" + char(34) + \"");
s++;
} else {
Putc(*s++, ErrFp);
}
}
Putc('"', ErrFp);
if (*s) fprintf(ErrFp, "...");
Putc('\n', ErrFp);
} else if (v->type == DATE_TYPE) {
Value val;
val.type = DATE_TYPE;
val.v.val = * (int *) v->value;
PrintValue(&val, ErrFp);
Putc('\n', ErrFp);
} else {
if (!v->modifiable) fprintf(ErrFp, "%d\n", *((int *)v->value));
else {
fprintf(ErrFp, "%-10d ", *((int *)v->value));
if (v->min == ANY) fprintf(ErrFp, "(-Inf, ");
else fprintf(ErrFp, "[%d, ", v->min);
if (v->max == ANY) fprintf(ErrFp, "Inf)\n");
else fprintf(ErrFp, "%d]\n", v->max);
}
}
} else fprintf(ErrFp, "%s\n", UNDEF);
return;
}
bool HLXSListTest::HandleSetAtCmd(const UTVector<UTString>& info)
{
bool ret = false;
int value = 0;
if (!UTParamUtil::GetInt(info[1], value))
{
DPRINTF(D_ERROR, ("npSList::HandleSetAtCmd : failed to convert parameter\n"));
}
else
{
DestroyValue(m_list.GetAt(m_pos));
m_list.SetAt(m_pos, CreateValue(value));
ret = true;
}
return ret;
}
bool HLXSListTest::HandleReplacePrevCmd(const UTVector<UTString>& info)
{
bool ret = false;
int value = 0;
if (!UTParamUtil::GetInt(info[1], value))
{
DPRINTF(D_ERROR, ("npSList::HandleReplacePrevCmd : failed to convert parameter\n"));
}
else
{
LISTPOSITION tmpPos = m_pos;
DestroyValue(m_list.GetPrev(tmpPos));
m_list.GetPrev(m_pos) = CreateValue(value);
ret = true;
}
return ret;
}
int DeleteVar(char const *str)
{
register int h;
register Var *v;
register Var *prev;
h = HashVal(str) % VAR_HASH_SIZE;
v = VHashTbl[h];
prev = NULL;
while(v) {
if (! StrinCmp(str, v->name, VAR_NAME_LEN)) break;
prev = v;
v = v-> next;
}
if (!v) return E_NOSUCH_VAR;
DestroyValue(v->v);
if (prev) prev->next = v->next; else VHashTbl[h] = v->next;
free(v);
return OK;
}
bool HLXSListTest::HandleRemoveTailCmd(const UTVector<UTString>& /*info*/)
{
DestroyValue(m_list.RemoveTail());
return true;
}
static int DoCalRem(ParsePtr p, int col)
{
int oldLen;
Trigger trig;
TimeTrig tim;
Value v;
int r, err;
int jul;
CalEntry *CurCol = CalColumn[col];
CalEntry *e;
char const *s, *s2;
DynamicBuffer buf, obuf, pre_buf;
Token tok;
int is_color, col_r, col_g, col_b;
is_color = 0;
DBufInit(&buf);
DBufInit(&pre_buf);
/* Parse the trigger date and time */
if ( (r=ParseRem(p, &trig, &tim, 1)) ) {
FreeTrig(&trig);
return r;
}
/* Don't include timed reminders in calendar if -a option supplied. */
if (DontIssueAts && tim.ttime != NO_TIME) {
FreeTrig(&trig);
return OK;
}
if (trig.typ == NO_TYPE) {
FreeTrig(&trig);
return E_EOLN;
}
if (trig.typ == SAT_TYPE) {
r=DoSatRemind(&trig, &tim, p);
if (r) {
FreeTrig(&trig);
if (r == E_EXPIRED) return OK;
return r;
}
if (!LastTrigValid) {
FreeTrig(&trig);
return OK;
}
r=ParseToken(p, &buf);
if (r) {
FreeTrig(&trig);
return r;
}
FindToken(DBufValue(&buf), &tok);
DBufFree(&buf);
if (tok.type == T_Empty || tok.type == T_Comment) {
FreeTrig(&trig);
return OK;
}
if (tok.type != T_RemType || tok.val == SAT_TYPE) {
FreeTrig(&trig);
return E_PARSE_ERR;
}
if (tok.val == PASSTHRU_TYPE) {
r=ParseToken(p, &buf);
if (r) return r;
if (!DBufLen(&buf)) {
DBufFree(&buf);
FreeTrig(&trig);
return E_EOLN;
}
StrnCpy(trig.passthru, DBufValue(&buf), PASSTHRU_LEN);
DBufFree(&buf);
}
trig.typ = tok.val;
jul = LastTriggerDate;
if (!LastTrigValid) {
FreeTrig(&trig);
return OK;
}
} else {
/* Calculate the trigger date */
jul = ComputeTrigger(trig.scanfrom, &trig, &r, 1);
if (r) {
FreeTrig(&trig);
return r;
}
}
/* Convert PS and PSF to PASSTHRU */
if (trig.typ == PS_TYPE) {
strcpy(trig.passthru, "PostScript");
trig.typ = PASSTHRU_TYPE;
} else if (trig.typ == PSF_TYPE) {
strcpy(trig.passthru, "PSFile");
trig.typ = PASSTHRU_TYPE;
}
if (trig.typ == PASSTHRU_TYPE) {
if (!PsCal && strcmp(trig.passthru, "COLOR") && strcmp(trig.passthru, "COLOUR")) {
FreeTrig(&trig);
return OK;
}
if (!strcmp(trig.passthru, "COLOR") ||
!strcmp(trig.passthru, "COLOUR")) {
is_color = 1;
/* Strip off the three color numbers */
DBufFree(&buf);
r=ParseToken(p, &buf);
DBufPuts(&pre_buf, DBufValue(&buf));
DBufPutc(&pre_buf, ' ');
DBufFree(&buf);
if (r) {
FreeTrig(&trig);
return r;
}
r=ParseToken(p, &buf);
DBufPuts(&pre_buf, DBufValue(&buf));
DBufPutc(&pre_buf, ' ');
DBufFree(&buf);
if (r) {
FreeTrig(&trig);
return r;
}
r=ParseToken(p, &buf);
DBufPuts(&pre_buf, DBufValue(&buf));
DBufPutc(&pre_buf, ' ');
DBufFree(&buf);
if (r) {
FreeTrig(&trig);
return r;
}
(void) sscanf(DBufValue(&pre_buf), "%d %d %d",
&col_r, &col_g, &col_b);
if (col_r < 0) col_r = 0;
else if (col_r > 255) col_r = 255;
if (col_g < 0) col_g = 0;
else if (col_g > 255) col_g = 255;
if (col_b < 0) col_b = 0;
else if (col_b > 255) col_b = 255;
if (!PsCal && !DoSimpleCalendar) {
DBufFree(&pre_buf);
}
}
}
/* If trigger date == today, add it to the current entry */
DBufInit(&obuf);
if ((jul == JulianToday) ||
(DoSimpleCalDelta &&
ShouldTriggerReminder(&trig, &tim, jul, &err))) {
NumTriggered++;
if (DoSimpleCalendar || tim.ttime != NO_TIME) {
/* Suppress time if it's not today or if it's a non-COLOR special */
if (jul != JulianToday ||
(trig.typ == PASSTHRU_TYPE &&
strcmp(trig.passthru, "COLOUR") &&
strcmp(trig.passthru, "COLOR"))) {
if (DBufPuts(&obuf, SimpleTime(NO_TIME)) != OK) {
DBufFree(&obuf);
DBufFree(&pre_buf);
FreeTrig(&trig);
return E_NO_MEM;
}
} else {
if (DBufPuts(&obuf, CalendarTime(tim.ttime, tim.duration)) != OK) {
DBufFree(&obuf);
DBufFree(&pre_buf);
FreeTrig(&trig);
return E_NO_MEM;
}
}
}
if (trig.typ != PASSTHRU_TYPE &&
UserFuncExists("calprefix")==1) {
char evalBuf[64];
sprintf(evalBuf, "calprefix(%d)", trig.priority);
s2 = evalBuf;
r = EvalExpr(&s2, &v, NULL);
if (!r) {
if (!DoCoerce(STR_TYPE, &v)) {
if (DBufPuts(&obuf, v.v.str) != OK) {
DestroyValue(v);
DBufFree(&obuf);
DBufFree(&pre_buf);
FreeTrig(&trig);
return E_NO_MEM;
}
}
DestroyValue(v);
}
}
oldLen = DBufLen(&obuf);
/* In -sa mode, run in ADVANCE mode if we're triggering
* before the actual date */
if (jul != JulianToday) {
r = DoSubst(p, &obuf, &trig, &tim, jul, ADVANCE_MODE);
} else {
r = DoSubst(p, &obuf, &trig, &tim, jul, CAL_MODE);
}
if (r) {
DBufFree(&pre_buf);
DBufFree(&obuf);
FreeTrig(&trig);
return r;
}
if (DBufLen(&obuf) <= oldLen) {
DBufFree(&obuf);
DBufFree(&pre_buf);
FreeTrig(&trig);
return OK;
}
if (trig.typ != PASSTHRU_TYPE &&
UserFuncExists("calsuffix")==1) {
char evalBuf[64];
sprintf(evalBuf, "calsuffix(%d)", trig.priority);
s2 = evalBuf;
r = EvalExpr(&s2, &v, NULL);
if (!r) {
if (!DoCoerce(STR_TYPE, &v)) {
if (DBufPuts(&obuf, v.v.str) != OK) {
DestroyValue(v);
DBufFree(&obuf);
DBufFree(&pre_buf);
FreeTrig(&trig);
return E_NO_MEM;
}
}
DestroyValue(v);
}
}
s = DBufValue(&obuf);
if (!DoSimpleCalendar) while (isempty(*s)) s++;
DBufPuts(&pre_buf, s);
s = DBufValue(&pre_buf);
e = NEW(CalEntry);
if (!e) {
DBufFree(&obuf);
DBufFree(&pre_buf);
FreeTrig(&trig);
return E_NO_MEM;
}
#ifdef REM_USE_WCHAR
e->wc_pos = NULL;
e->wc_text = NULL;
#endif
e->is_color = is_color;
e->r = col_r;
e->g = col_g;
e->b = col_b;
e->text = StrDup(s);
DBufFree(&obuf);
DBufFree(&pre_buf);
if (!e->text) {
free(e);
FreeTrig(&trig);
return E_NO_MEM;
}
make_wchar_versions(e);
DBufInit(&(e->tags));
DBufPuts(&(e->tags), DBufValue(&(trig.tags)));
if (SynthesizeTags) {
AppendTag(&(e->tags), SynthesizeTag());
}
/* Don't need tags any more */
FreeTrig(&trig);
e->duration = tim.duration;
e->priority = trig.priority;
e->filename = StrDup(FileName);
if(!e->filename) {
free(e);
return E_NO_MEM;
}
e->lineno = LineNo;
if (trig.typ == PASSTHRU_TYPE) {
StrnCpy(e->passthru, trig.passthru, PASSTHRU_LEN);
} else {
e->passthru[0] = 0;
}
e->pos = e->text;
if (jul == JulianToday) {
e->time = tim.ttime;
} else {
e->time = NO_TIME;
}
e->next = CurCol;
CalColumn[col] = e;
SortCol(&CalColumn[col]);
}
return OK;
}
static
struct gl_list_t *FindNextNameElementPath(CONST struct Name *n,
struct gl_list_t *list,
enum find_errors *errval)
{
unsigned long pos,c,len;
struct InstanceName rec;
CONST struct Instance *current,*child;
struct value_t setvalue,oldvalue;
CONST struct Set *sptr;
struct gl_list_t *result;
PAN *p, *p2;
struct Name *n2;
*errval = correct_instance;
if (NameId(n)){
result = gl_create(NAMELISTSIZE);
SetInstanceNameType(rec,StrName);
SetInstanceNameStrPtr(rec,NameIdPtr(n));
len = gl_length(list);
for (c=1; c<=len; c++){
p = (PAN *)gl_fetch(list,c);
current = p->i;
pos = ChildSearch(current,&rec);
if (pos!=0){
child = InstanceChild(current,pos);
if (child!=NULL){
n2 = CopyAppendNameNode(p->n, n);
p2 = CreatePAN(child, n2);
gl_append_ptr(result,(VOIDPTR)p2);
} else{
*errval = unmade_instance;
DestroyPANList(&result);
return NULL;
}
} else{
*errval = unmade_instance;
/* it would seem this ought to be undefined_instance,
* but maybe refinement causes insanity. -- in which case
* it should be a caller policy to wait, rather than our
* job to anticipate policy and short circuit things here.
*/
DestroyPANList(&result);
return NULL;
}
}
return result;
} else {
sptr = NameSetPtr(n);
setvalue = EvaluateSet(sptr,InstanceEvaluateName);
switch(ValueKind(setvalue)){
case integer_value:
case symbol_value:
case list_value:
oldvalue = setvalue;
if (ListMode) {
setvalue = CreateOrderedSetFromList(oldvalue);
} else {
setvalue = CreateSetFromList(oldvalue);
}
DestroyValue(&oldvalue);
/* intended to fall through to next case */
case set_value:
result = FindArrayChildrenPath(list,SetValue(setvalue),errval);
DestroyValue(&setvalue);
return result;
case error_value:
switch(ErrorValue(setvalue)){
case illegal_set_use:
*errval = impossible_instance;
break;
default:
*errval = undefined_instance;
break;
/* more needs to be added here */
}
DestroyValue(&setvalue);
return NULL;
default:
ASC_PANIC("Need to add to FindNextNameElementPath.\n");
exit(2);/* Needed to keep gcc from whining */
}
}
}