//==========================================================================
// проверяет поглощение одного типа другим
//--------------------------------------------------------------------------
// t1 - [in] 1-й тип
// t2 - [in] 2-й тип
//==========================================================================
Type* GetMaxType(Type *t1, Type *t2)
{
if (CompareType(t1, t2)) return t1;
if (CompareType(t2, t1)) return t2;
return 0;
}
unit_t * unit_new (svc_t * svc, svc_instance_t * inst)
{
#define CompareType(typ) \
!strcasecmp (svc_object_get_property_string (svc, "Unit.Strategy"), typ)
unit_t * unitnew = s16mem_alloc (sizeof (unit_t));
unitnew->name = inst_object_get_property_string (inst, "S16.FMRI");
unitnew->state = S_OFFLINE;
unitnew->svc = svc;
unitnew->inst = inst;
unitnew->timer_id = 0;
unitnew->main_pid = 0;
unitnew->rtype = R_YES;
unitnew->state = S_OFFLINE;
unitnew->pids = List_new ();
if (!unitnew->pids)
{
fprintf (stderr, "unit alloc! (%s pids)\n",
inst_object_get_property_string (inst, "S16.FMRI"));
return 0;
}
if (CompareType ("exec"))
unitnew->type = T_EXEC;
else if (CompareType ("forks"))
unitnew->type = T_FORKS;
else if (CompareType ("oneshot"))
unitnew->type = T_ONESHOT;
else
{
fprintf (stderr, "Unit <%s> lacks a known type\n", unitnew->name);
List_destroy (unitnew->pids);
s16mem_free (unitnew);
return 0;
}
unitnew->method[M_PRESTART] =
svc_object_get_property_string (svc, "Method.Prestart");
unitnew->method[M_START] =
svc_object_get_property_string (svc, "Method.Start");
unitnew->method[M_POSTSTART] =
svc_object_get_property_string (svc, "Method.Poststart");
unitnew->method[M_STOP] =
svc_object_get_property_string (svc, "Method.Stop");
unitnew->timeout_secs = 12;
fprintf (stderr, "[%s] new unit formed\n", unitnew->name);
return unitnew;
}
//==========================================================================
// сравнивает два типа массив
//--------------------------------------------------------------------------
// t1 - [in] 1-й тип массив
// t2 - [in] 2-й тип массив
//==========================================================================
bool CompareTypeArray(TypeArray *t1, TypeArray *t2)
{
if(t1->size == 0 && t2->size == 0) // открытые массивы
return CompareType(t1->type, t2->type);
return false;
}
//==========================================================================
// сравнивает два типа указателя
//--------------------------------------------------------------------------
// t1 - [in] 1-й тип указатель
// t2 - [in] 2-й тип указатель
//==========================================================================
bool CompareTypePtr(TypePtr *t1, TypePtr *t2)
{
// проверка на присвоение NULL
if (!t1->IsNil && t2->IsNil || t1->IsNil && t2->IsNil)
return true;
return CompareType(t1->type, t2->type);
}
//==========================================================================
// сравнивает специализацию и простой тип
//--------------------------------------------------------------------------
// t1 - [in] 1-й тип обобщение
// t2 - [in] 2-й тип специализация
//==========================================================================
bool CompareTypeSpec(Type *t1, TypeSpec *t2)
{
Type* t = static_cast<Type*>(t2->base);
if (!t)
return false;
// проверяем тип спец-ии
return CompareType(t1, t);
}
bool benchIntrusive(BenchmarkParameters ¶ms)
{
std::vector<uint64_t> &keys = *reinterpret_cast<std::vector<uint64_t>*>(params.arg0);
std::vector<DataType> values;
values.reserve(params.itemCount);
for(int i = 0; i < params.itemCount; ++i)
{
DataType d;
d.key = keys[i];
values.push_back(d);
}
{
MapType m;
for(DataType &d : values)
{
m.insert(d);
}
if(m.size() != static_cast<uint64_t>(params.itemCount))
{
return false;
}
int64_t searchCounter = 0;
uint64_t ticks = getTicks();
//=======================================================================
while(searchCounter < params.iterCount)
{
for(int i = 0; i < params.itemCount && searchCounter < params.iterCount; ++i, ++searchCounter)
{
auto iter = m.find(keys[i], CompareType());
if(iter == m.end() || iter->key != keys[i])
{
return false;
}
}
}
//=======================================================================
params.ticks = getTicks() - ticks;
}
return true;
}
/*
============
PR_ParseFunctionCall
============
*/
def_t *PR_ParseFunctionCall (def_t *func)
{
def_t *e;
int arg;
type_t *t;
t = func->type;
if (t->type != ev_function)
PR_ParseError ("not a function");
// copy the arguments to the global parameter variables
arg = 0;
if (!PR_Check(")"))
{
do
{
if (arg >= t->num_parms || arg >= MAX_PARMS /* works properly with varargs */)
PR_ParseError ("too many parameters");
e = PR_Expression (TOP_PRIORITY);
if (arg < (t->num_parms & VA_MASK) && !CompareType(e->type, t->parm_types[arg]))
PR_ParseError ("type mismatch on parm %i", arg);
// a vector copy will copy everything
def_parms[arg].type = t->parm_types[arg];
PR_Statement (&pr_opcodes[OP_STORE_V], e, &def_parms[arg]);
arg++;
} while (PR_Check (","));
if (arg < (t->num_parms & VA_MASK))
PR_ParseError ("too few parameters");
PR_Expect (")");
}
if (arg > MAX_PARMS)
PR_ParseError ("more than %d parameters", (int)MAX_PARMS);
PR_Statement (&pr_opcodes[OP_CALL0+arg], func, 0);
def_ret.type = t->aux_type;
return &def_ret;
}
/*
================
PR_ParseInitialization
"<type> <name> = " was parsed, parse the rest
================
*/
void PR_ParseInitialization (type_t *type, char *name, def_t *def)
{
if (def->initialized)
PR_ParseError ("%s redeclared", name);
if (pr_token_type != tt_immediate && pr_token_type != tt_name)
PR_ParseError ("syntax error : '%s'", pr_token);
if (pr_token_type == tt_name) {
PR_ParseError ("initializer is not a constant");
}
if (!CompareType(pr_immediate_type, type))
PR_ParseError ("wrong immediate type for %s", name);
def->initialized = 1;
if (type == &type_const_string || type == &type_string)
pr_immediate.string = CopyString (pr_immediate_string);
memcpy (pr_globals + def->ofs, &pr_immediate, 4*type_size[pr_immediate_type->type]);
PR_Lex ();
}
//==========================================================================
// сравнивает два процедурных типа
//--------------------------------------------------------------------------
// t1 - [in] 1-й процедурный тип
// t2 - [in] 2-й процедурный тип
//==========================================================================
bool CompareTypeProc(TypeProcedure *t1, TypeProcedure *t2)
{
if(t1->formalParams.size() == t2->formalParams.size() && t1->returnType == t2->returnType)
{
// сравниваю параметры
for(unsigned int i = 0; i < t1->formalParams.size(); ++i)
{
Parameter *p1 = t1->formalParams[i];
Parameter *p2 = t2->formalParams[i];
if((p1->type->WhatIsIt() == ItIsTypeRef && p2->type->WhatIsIt() == ItIsTypeRef) ||
(p1->type->WhatIsIt() != ItIsTypeRef && p2->type->WhatIsIt() != ItIsTypeRef))
{
if(!CompareType(p1->type, p2->type))
return false;
}
else
return false;
}
return true;
}
return false;
}
void Visit(const Waypoint &waypoint) {
if (CompareType(waypoint, type_index) &&
(filter_data.distance_index == 0 || CompareName(waypoint, name)) &&
CompareDirection(waypoint, direction_index, location, heading))
waypoint_list.push_back(WaypointListItem(waypoint));
}
