/* Add PkgNode to package hashtable */
static void add_pkg(gpointer data, gpointer user_data) {
PkgNode *pkg = (PkgNode *)data;
GHashTable *ht_packages = (GHashTable *)(((gpointer *)user_data)[0]);
HostNode *node = (HostNode *)(((gpointer *)user_data)[1]);
ASSERT_TYPE(pkg, T_PKGNODE);
ASSERT_TYPE(node, T_HOSTNODE);
if (!test_pkg(pkg))
return;
gchar *v;
if(((pkg->flag & HOST_STATUS_PKGUPDATE) ||
(pkg->flag & HOST_STATUS_PKGKEPTBACK)) &&
(pkg->data))
v = pkg->data;
else
v = pkg->version;
if(!v)
return;
/* Create packages hashtable if needed. */
GList *l_versions = g_hash_table_lookup(ht_packages, pkg->package);
Version _v;
#ifndef NDEBUG
_v._type = T_VERSION;
#endif
_v.version = v;
/* Create version entry if needed. */
Version *vers = NULL;
GList *l_v = g_list_find_custom(l_versions, &_v, cmp_vers);
if (l_v) {
vers = (Version *)l_v->data;
ASSERT_TYPE(vers, T_VERSION);
}
if(!vers) {
vers = g_malloc(sizeof(Version));
#ifndef NDEBUG
vers->_type = T_VERSION;
#endif
vers->version = strdup(v);
vers->ts_first = node->last_upd;
vers->nodes = NULL;
l_versions = g_list_prepend(l_versions, vers);
g_hash_table_insert(ht_packages, g_strdup(pkg->package), l_versions);
}
else if (vers->ts_first > node->last_upd) {
vers->ts_first = node->last_upd;
}
vers->nodes = g_list_prepend(vers->nodes, node);
}
TEST_F(BasicParserTest, MultipleImports)
{
chime::node* node;
chime::Import* import;
node = parse("import Yo\nimport Sup\n");
import = static_cast<chime::Import*>(node->childAtIndex(0));
ASSERT_IMPORT(import);
ASSERT_TYPE("Yo", import->getImportand());
import = static_cast<chime::Import*>(node->childAtIndex(1));
ASSERT_IMPORT(import);
ASSERT_TYPE("Sup", import->getImportand());
}
/* Trigger refresh for any node which has older version data. */
static void add_refresh(gpointer value, gpointer user_data) {
Version *version = (Version *)value;
ASSERT_TYPE(version, T_VERSION);
g_list_foreach(version->nodes, check_refresh, user_data);
}
static inline SnString* call_to_string(VALUE self) {
static bool got_sym = false;
static SnSymbol to_string;
if (!got_sym) { to_string = snow_symbol("to_string"); got_sym = true; }
SnString* str = ((snow_typeof(self) == SN_STRING_TYPE) ? (SnString*)self : (SnString*)snow_call_method(self, to_string, 0));
ASSERT_TYPE(str, SN_STRING_TYPE);
return str;
}
/* Hash a distri. */
static guint distri_hash(gconstpointer key) {
Distri *distri = (Distri *)key;
gchar b[0x1ff];
ASSERT_TYPE(distri, T_DISTRI);
return g_str_hash(distri2str(distri, b, sizeof(b)));
}
/*
Unalloc reader
*/
Node *free_reader(Node *node)
{
ASSERT(node, "free_reader : null environment");
ASSERT_TYPE(node, READER, "free_reader : Bad type %s", str_type(node->type));
// if(node->val.function->closure)
// node->val.function->closure = free_node(node->val.function->closure);
return NULL;
}
static inline SnString* call_inspect(VALUE self) {
static bool got_sym = false;
static SnSymbol inspect;
if (!got_sym) { inspect = snow_symbol("inspect"); got_sym = true; }
SnString* str = snow_call_method(self, inspect, 0);
ASSERT_TYPE(str, SN_STRING_TYPE);
return str;
}
TEST_F(BasicParserTest, ImportIdentifier)
{
chime::Node* node;
node = parse("import Yo.Dog")->childAtIndex(0);
ASSERT_IMPORT(node);
ASSERT_TYPE("Yo.Dog", static_cast<chime::Import*>(node)->getImportand());
}
/* Remove PkgNode from package hashtable */
static void rem_pkg(gpointer data, gpointer user_data) {
PkgNode *pkg = (PkgNode *)data;
GHashTable *ht_packages = (GHashTable *)(((gpointer *)user_data)[0]);
HostNode *node = (HostNode *)(((gpointer *)user_data)[1]);
ASSERT_TYPE(pkg, T_PKGNODE);
ASSERT_TYPE(node, T_HOSTNODE);
if (!test_pkg(pkg))
return;
/* Lookup packages hashtable. */
GList *l_versions = g_hash_table_lookup(ht_packages, pkg->package);
if(!l_versions)
return;
/* Lookup version list. */
gchar *v = NULL;
if(((pkg->flag & HOST_STATUS_PKGUPDATE) ||
(pkg->flag & HOST_STATUS_PKGKEPTBACK)) &&
(pkg->data))
v = pkg->data;
else
v = pkg->version;
Version _v;
#ifndef NDEBUG
_v._type = T_VERSION;
#endif
_v.version = v;
Version *vers = NULL;
GList *l_v = g_list_find_custom(l_versions, &_v, cmp_vers);
if (l_v) {
vers = (Version *)l_v->data;
ASSERT_TYPE(vers, T_VERSION);
}
if(!vers)
return;
vers->nodes = g_list_remove(vers->nodes, node);
}
/**
* Add node to refresh list if:
* - last refresh is older than the time this version was
* seen by apt-dater first
* - the node is allowed to refresh
**/
static void check_refresh(gpointer data, gpointer user_data) {
HostNode *node = (HostNode *)data;
int *ts_first = (int *)user_data;
ASSERT_TYPE(node, T_HOSTNODE);
if(node && (node->last_upd < *ts_first) &&
((node->forbid & HOST_FORBID_REFRESH) == 0) &&
(g_list_find(refresh_nodes, node) == NULL))
refresh_nodes = g_list_prepend(refresh_nodes, node);
}
TEST_F(BasicParserTest, NamespacedTypeMethodCall)
{
chime::node* node;
chime::binary_operator* op;
node = parse("Some.Type.call()");
op = (chime::binary_operator*)node->childAtIndex(0);
ASSERT_OPERATOR(".", op);
ASSERT_TYPE("Some.Type", op->left_operand());
ASSERT_METHOD_CALL("call", op->right_operand());
}
/*
* @description Compare one bool to another.
* @argument Value to compare to
* @return Integer
*/
EH_METHOD(Bool, compare) {
ASSERT_TYPE(args, Bool, "Bool.compare");
ASSERT_OBJ_TYPE(Bool, "Bool.compare");
bool lhs = obj->get<Bool>();
bool rhs = args->get<Bool>();
if(lhs == rhs) {
return Integer::make(0);
} else if(lhs == false) {
return Integer::make(-1);
} else {
return Integer::make(1);
}
}
SnFunction* snow_create_function_from_description(SnFunctionDescription* desc)
{
ASSERT(desc);
ASSERT_TYPE(desc, SN_FUNCTION_DESCRIPTION_TYPE);
ASSERT(desc->func);
SnFunction* func = (SnFunction*)snow_alloc_any_object(SN_FUNCTION_TYPE, sizeof(SnFunction) + sizeof(struct SnVariableReference)*desc->num_variable_reference_descriptions);
snow_object_init((SnObject*)func, snow_get_prototype(SN_FUNCTION_TYPE));
func->desc = desc;
func->declaration_context = NULL;
func->num_variable_references = desc->num_variable_reference_descriptions;
memset(func->variable_references, 0, sizeof(struct SnVariableReference)*func->num_variable_references);
return (SnFunction*)snow_reset_object_assigned(func);
}
TEST_F(BasicParserTest, MethodWithOperatorsOnType)
{
chime::method_definition* method;
chime::binary_operator* op;
method = parse_method_def("method foo() { Bar.baz() }");
ASSERT_METHOD_DEFINITION("foo", method);
op = static_cast<chime::binary_operator*>(method->getBody()->childAtIndex(0));
ASSERT_OPERATOR(".", op);
ASSERT_TYPE("Bar", op->getLeftOperand());
ASSERT_METHOD_CALL("baz", op->getRightOperand());
}
TEST_F(BasicParserTest, AssignmentFromTypeMethodCall)
{
chime::binary_operator* op;
op = (chime::binary_operator*)parse("a = Foo.Bar.baz()")->childAtIndex(0);
ASSERT_GLOBAL_ASSIGNMENT(op);
ASSERT_GLOBAL_VARIABLE("a", op->getLeftOperand());
op = (chime::binary_operator*)op->getRightOperand();
ASSERT_OPERATOR(".", op);
ASSERT_TYPE("Foo.Bar", op->getLeftOperand());
ASSERT_METHOD_CALL("baz", op->getRightOperand());
}
/*
String representation of reader
returns linked allocated String
*/
Node *string_reader(Node *node)
{
ASSERT(node, "string_reader : null environment");
ASSERT_TYPE(node, READER, "string_env : Bad type %s", str_type(node->type));
// if(node->val.function->closure)
// {
// Node *map = string_node(node->val.function->closure);
// Node *res = sprintf_string("<%s macro=%s special=%s closure=%s>",
// node->val.function->is_macro ? "yes" : "no",
// node->val.function->is_special ? "yes" : "no",
// str_type(FUNCTION),
// map->val.string);
// unlink_node(map);
// return res;
// }
return sprintf_string("<%s FILE*=?>",
// node->val.function->is_macro ? "yes" : "no",
// node->val.function->is_special ? "yes" : "no",
str_type(FUNCTION));
}
/*
* @description Compare two maps.
* @argument Map to compare to.
* @returns Integer (as specified for Object.compare)
*/
EH_METHOD(Map, compare) {
ASSERT_RESOURCE(Map, "Map.compare");
ASSERT_TYPE(args, Map, "Map.compare");
eh_map_t *lhs = data;
eh_map_t *rhs = args->get<Map>();
eh_map_t::iterator lhs_it = lhs->map.begin();
eh_map_t::iterator rhs_it = rhs->map.begin();
eh_map_t::iterator lhs_end = lhs->map.end();
eh_map_t::iterator rhs_end = rhs->map.end();
while(true) {
// check whether we've reached the end
if(lhs_it == lhs_end) {
if(rhs_it == rhs_end) {
break;
} else {
return Integer::make(-1);
}
} else if(rhs_it == rhs_end) {
return Integer::make(1);
}
// compare keys
int key_cmp = ehi->compare(lhs_it->first, rhs_it->first, obj);
if(key_cmp != 0) {
return Integer::make(key_cmp);
}
// compare values
int value_cmp = ehi->compare(lhs_it->second, rhs_it->second, obj);
if(value_cmp != 0) {
return Integer::make(value_cmp);
}
// continue iteration
lhs_it++;
rhs_it++;
}
return Integer::make(0);
}
/* Check if refresh is needed for each package. */
static void trigger_package(gpointer key, gpointer value, gpointer user_data) {
GList *l_versions = (GList *)value;
GHashTable *ht_packages = (GHashTable *)user_data;
if(l_versions == NULL)
return;
l_versions = g_list_sort(l_versions, cmp_vers);
if (value != l_versions)
g_hash_table_insert(ht_packages, g_strdup(key), l_versions);
Version *newest = (Version *)(l_versions->data);
ASSERT_TYPE(newest, T_VERSION);
GList *l_oldvers = g_list_next(l_versions);
/* Only one version known => nothing todo. */
if(l_oldvers == NULL)
return;
/* Any host, which has last_upd < version->ts_first needs to be refreshed. */
g_list_foreach(l_oldvers, add_refresh, &( newest -> ts_first ));
}
EH_METHOD(Map_Iterator, operator_colon) {
ASSERT_TYPE(args, Map, "Map.Iterator()");
return Map_Iterator::make(args, ehi->get_parent());
}
EH_METHOD(Node, execute) {
ASSERT_OBJ_TYPE(Enum_Instance, "Node.execute");
ASSERT_TYPE(args, Node_Context, "Node.execute");
return ehi->eh_execute(obj, *args->get<Node_Context>());
}
static gint cmp_vers(gconstpointer a, gconstpointer b) {
ASSERT_TYPE((Version *)a, T_VERSION);
ASSERT_TYPE((Version *)b, T_VERSION);
return -verrevcmp(((Version *)a)->version, ((Version *)b)->version);
}
static void continuation_gc_cleanup(VALUE vcc)
{
SnContinuation* cc = (SnContinuation*)vcc;
ASSERT_TYPE(cc, SN_CONTINUATION_TYPE);
snow_continuation_cleanup(cc);
}
EH_METHOD(JSON, parse) {
ASSERT_TYPE(args, String, "JSON.parse");
json_scanner js{ehi};
return js.parse(args->get<String>());
}
/*
* @description Compares null to itself.
* @argument Null
* @returns Always returns true
*/
EH_METHOD(Null, compare) {
ASSERT_OBJ_TYPE(Null, "Null.compare");
ASSERT_TYPE(args, Null, "Null.compare");
return Integer::make(0);
}
