masi/solvecraft
1
0
Fork 0
mirror of https://github.com/bherbruck/solidcraft.git synced 2026-11-08 13:01:52 +00:00
Code Issues Packages Projects Releases 1 Wiki Activity
Files
1fe74f087bdfd204d1a8aec4bc201f92a1c19f4d
solvecraft/harness/cpp/shim/geom_attribute.cpp
T
Andreas 6ac3722aae WIP topology.shell review round 2: mark locks, region states, ray guard 
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-17 04:51:37 +02:00

822 lines
30 KiB
C++
Raw Blame History

// SPDX-License-Identifier: Apache-2.0
// difftest shim for unit `geom.attribute`.
// Wraps upstream SmAttribute and its derived classes (source/SMLib/src/SmAttribute.cpp,
// source/SMLib/inc/SmAttribute.h) together with the SmAObject attribute-list calls
// that drive them (AddAttribute / RemoveAttribute / ClearAttributes / FindAttribute).
//
// sc_geom_attribute_run runs a script against `n_objects` attributed objects (bare
// SmRegion instances, never placed in a B-rep) and a table of attribute "handles"
// (attributes created by the script, MakeCopy results and the placeholders created by
// ReadIndexedAttributesFromDB). Each op is 7 int64s: [op, a, b, c, d, e, f].
// Attribute references (`ref`): ref >= 0 is a handle index; ref < 0 is entry
// (k % 1024) of object (k / 1024)'s attribute list, k = -ref - 1.
//
// Statuses: 0 ok, ST_INVALID (-1) the reference does not resolve, ST_SKIP (-2) the op
// would hit undefined behaviour upstream (the Rust runner applies the same rule to
// its own state), otherwise the upstream SmStatus.
//
// Memory safety rests on the invariant "objects listing an attribute are a sub-multiset
// of its users" (see crates/difftest/src/units/geom_attribute.rs): direct RemoveUser /
// fromClearAttributes run only on attributes no object lists, and `delete` only on
// attributes with no users or standalone attributes whose users all list them. Which
// handles get deleted is predicted from the state before the op (upstream gives no
// way to observe a deletion); everything else in the dump is read back from upstream.
//
// Output (int64 stream, doubles in a second stream):
// per op: status, n_out, out...
// n_handles, alive[n_handles], canon[n_handles] (canonical index or -1)
// n_attrs, per attr: kind, type, id, behavior, n_users, users..., n_vals, vals..., n_dbls
// per object: n, canonical indices...
// n_all, all[n_all] (handle index or -1)
// stream state, stream position (-1 -1 without a stream)
#include "sc_shim.h"
#include <SmApiGeneral.h>
#include <SmAttribute.h>
#include <SmDatabaseIO.h>
#include <SmBrep.h>
#include <SmRegion.h>
#include <cctype>
#include <cstring>
#include <map>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
namespace
{
enum Op : int64_t
{
OP_NEW_PLAIN = 0,
OP_NEW_GENERIC = 1,
OP_NEW_LONG = 2,
OP_NEW_POINTER = 3,
OP_NEW_POINTER_LIST = 4,
OP_NEW_VECTOR3D = 5,
OP_NEW_COLOR = 6,
OP_NEW_TAG = 7,
OP_NEW_MERGE_REGION = 8,
OP_MAKE_COPY = 9,
OP_ADD_ATTRIBUTE = 10,
OP_REMOVE_ATTRIBUTE = 11,
OP_CLEAR_ATTRIBUTES = 12,
OP_SPLIT = 13,
OP_COPY = 14,
OP_MERGE = 15,
OP_COINCIDENT = 16,
OP_EDIT = 17,
OP_DESTRUCTION = 18,
OP_PROPAGATE = 19,
OP_ADD_USER = 20,
OP_REMOVE_USER = 21,
OP_GET_USERS = 22,
OP_QUERY = 23,
OP_MR_QUERY = 24,
OP_MR_SET_REGIONS = 25,
OP_MR_SET_OPERATION = 26,
OP_SET_VECTOR = 27,
OP_DESTROY = 28,
OP_READ_INDEXED = 29,
OP_FIND = 30,
OP_FROM_CLEAR = 31,
OP_SET_IS_VOID = 32,
OP_MAKE_INFINITE = 33,
OP_LAST = 33,
};
const int64_t ST_INVALID = -1;
const int64_t ST_SKIP = -2;
const int64_t REF_STRIDE = 1024;
const unsigned long READ_CAP = 1ul << 20;
enum Kind : int64_t
{
K_PLAIN = 0,
K_GENERIC = 1,
K_LONG = 2,
K_POINTER = 3,
K_POINTER_LIST = 4,
K_VECTOR3D = 5,
K_MERGE_REGION = 6,
K_TAG = 7,
K_COLOR = 8,
};
const SM_TYPE QUERY_TYPES[11] = {SmObject_TYPE, SmAttribute_TYPE, SmLongAttribute_TYPE,
SmVector3dAttribute_TYPE, SmGenericAttribute_TYPE, SmPointerAttribute_TYPE,
SmPointerListAttribute_TYPE, SmMergeRegionAttribute_TYPE,
SmTagAttribute_TYPE, SmColorAttribute_TYPE, CONT_BASE_TYPE};
struct ShimRegion : public SmRegion
{
ShimRegion() : SmRegion() {}
// SmTopology only offers `new (SmObject*)`; allocate from the context directly.
static void* operator new(size_t size, const SmContext& c) { return SmObject::operator new(size, c); }
static void operator delete(void* p, const SmContext&) { smos_Free(p); }
static void operator delete(void* p) { smos_Free(p); }
};
int64_t kind_of(const SmAttribute* a)
{
switch (a->GetType())
{
case SmAttribute_TYPE:
return K_PLAIN;
case SmGenericAttribute_TYPE:
return K_GENERIC;
case SmLongAttribute_TYPE:
return K_LONG;
case SmPointerAttribute_TYPE:
return a->IsKindOf(SmMergeRegionAttribute_TYPE) ? K_MERGE_REGION : K_POINTER;
case SmPointerListAttribute_TYPE:
return K_POINTER_LIST;
case SmVector3dAttribute_TYPE:
return a->IsKindOf(SmColorAttribute_TYPE) ? K_COLOR : K_VECTOR3D;
case SmTagAttribute_TYPE:
return K_TAG;
default:
return -1;
}
}
bool is_vector(const SmAttribute* a)
{
int64_t k = kind_of(a);
return k == K_VECTOR3D || k == K_COLOR;
}
bool standalone(const SmAttribute* a)
{
return a->GetBehavior() == SM_AB_STANDALONE_COPY || a->GetBehavior() == SM_AB_STANDALONE_REFERENCE;
}
struct Run
{
const SmContext* ctx = nullptr;
std::vector<SmRegion*> objs;
std::vector<SmAttribute*> handles;
std::vector<bool> alive;
SmTArray<SmAttribute*> all;
std::vector<int64_t> all_handle; // handle index of each placeholder slot (-1 empty)
std::vector<int64_t> pay_i;
std::vector<double> pay_d;
size_t pi = 0, pd = 0;
std::string data;
std::unique_ptr<std::istringstream> iss;
std::unique_ptr<SmDatabaseIO> db;
bool bad_payload = false;
int64_t next_i()
{
if (pi >= pay_i.size())
{
bad_payload = true;
return 0;
}
return pay_i[pi++];
}
double next_d()
{
if (pd >= pay_d.size())
{
bad_payload = true;
return 0.0;
}
return pay_d[pd++];
}
std::vector<SmAttribute*> list(int64_t o) const
{
SmTArray<SmAttribute*> t;
objs[(size_t)o]->GetAttributes(t);
std::vector<SmAttribute*> v;
for (ULONG i = 0; i < t.GetSize(); ++i)
v.push_back(t[i]);
return v;
}
std::vector<SmAObject*> users(const SmAttribute* a) const
{
SmTArray<SmAObject*> t;
a->GetUsers(t);
std::vector<SmAObject*> v;
for (ULONG i = 0; i < t.GetSize(); ++i)
v.push_back(t[i]);
return v;
}
int64_t obj_index(const void* p) const
{
for (size_t i = 0; i < objs.size(); ++i)
if ((const void*)objs[i] == p || (const void*)static_cast<SmAObject*>(objs[i]) == p)
return (int64_t)i;
return -999;
}
// Occurrences of `a` over all object lists.
int64_t listings(const SmAttribute* a) const
{
int64_t n = 0;
for (size_t o = 0; o < objs.size(); ++o)
for (SmAttribute* x : list((int64_t)o))
if (x == a) ++n;
return n;
}
SmAttribute* resolve(int64_t ref) const
{
if (ref >= 0)
{
if ((size_t)ref >= handles.size() || !alive[(size_t)ref]) return nullptr;
return handles[(size_t)ref];
}
int64_t k = -ref - 1;
int64_t o = k / REF_STRIDE, i = k % REF_STRIDE;
if (o < 0 || (size_t)o >= objs.size()) return nullptr;
std::vector<SmAttribute*> l = list(o);
if ((size_t)i >= l.size()) return nullptr;
return l[(size_t)i];
}
bool valid_obj(int64_t o) const { return o >= 0 && (size_t)o < objs.size(); }
void mark_dead(const SmAttribute* a)
{
for (size_t i = 0; i < handles.size(); ++i)
if (alive[i] && handles[i] == a) alive[i] = false;
}
int64_t add_handle(SmAttribute* a)
{
handles.push_back(a);
alive.push_back(true);
return (int64_t)handles.size() - 1;
}
};
bool is_c_space(char c)
{
return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
}
int64_t stream_pos(std::istream& in)
{
return (int64_t)in.rdbuf()->pubseekoff(0, std::ios_base::cur, std::ios_base::in);
}
uint64_t load_u64(const std::string& d, size_t at, bool swap)
{
unsigned char b[8];
std::memcpy(b, d.data() + at, 8);
if (swap)
for (int i = 0; i < 4; ++i)
std::swap(b[i], b[7 - i]);
uint64_t v;
std::memcpy(&v, b, 8);
return v;
}
// Whether ReadIndexedAttributesFromDB can run without upstream undefined behaviour.
bool read_is_safe(Run& r)
{
if (!r.db) return false;
std::istream* in = r.db->GetInStreamPtr();
if (in == nullptr || !in->good()) return false;
int64_t pos = stream_pos(*in);
if (pos < 0) return false;
if (r.db->GetFileType() == SM_ASCII)
{
for (size_t i = (size_t)pos; i < r.data.size(); ++i)
if (!is_c_space(r.data[i])) return true;
return false;
}
bool swap = r.db->GetByteSwap() != 0;
size_t p = (size_t)pos;
if (r.data.size() < p + 8) return false;
uint64_t n = load_u64(r.data, p, swap);
if (n > READ_CAP) return false;
if ((r.data.size() - p - 8) / 8 < n) return false;
for (uint64_t i = 0; i < n; ++i)
if (load_u64(r.data, p + 8 + 8 * (size_t)i, swap) > READ_CAP) return false;
return true;
}
// Runs one op; returns its status and appends outputs.
int64_t run_op(Run& r, const int64_t* a, std::vector<int64_t>& out)
{
const SmContext& ctx = *r.ctx;
int64_t op = a[0];
switch (op)
{
case OP_NEW_PLAIN:
out.push_back(r.add_handle(new (ctx) SmAttribute((ULONG)a[1], (SmAttributeBehaviorType)a[2])));
return 0;
case OP_NEW_GENERIC:
{
SmTArray<long> ls;
SmTArray<double> ds;
SmTArray<char> cs;
for (int64_t i = 0; i < a[3]; ++i)
ls.Add((long)r.next_i());
for (int64_t i = 0; i < a[4]; ++i)
ds.Add(r.next_d());
for (int64_t i = 0; i < a[5]; ++i)
cs.Add((char)(unsigned char)r.next_i());
if (r.bad_payload) return SC_ERR_ARG;
out.push_back(
r.add_handle(new (ctx) SmGenericAttribute((ULONG)a[1], (SmAttributeBehaviorType)a[2], ls, ds, cs)));
return 0;
}
case OP_NEW_LONG:
out.push_back(r.add_handle(new (ctx) SmLongAttribute((ULONG)a[1], (long)a[2], (SmAttributeBehaviorType)a[3])));
return 0;
case OP_NEW_POINTER:
out.push_back(r.add_handle(
new (ctx) SmPointerAttribute((ULONG)a[1], (void*)(uintptr_t)a[2], (SmAttributeBehaviorType)a[3])));
return 0;
case OP_NEW_POINTER_LIST:
{
SmTArray<SmObject*> l;
for (int64_t i = 0; i < a[3]; ++i)
l.Add((SmObject*)(uintptr_t)r.next_i());
if (r.bad_payload) return SC_ERR_ARG;
out.push_back(r.add_handle(
new (ctx) SmPointerListAttribute((ULONG)a[1], a[4] != 0 ? nullptr : &l, (SmAttributeBehaviorType)a[2])));
return 0;
}
case OP_NEW_VECTOR3D:
case OP_NEW_COLOR:
{
double x = r.next_d(), y = r.next_d(), z = r.next_d();
if (r.bad_payload) return SC_ERR_ARG;
SmVector3d v(x, y, z);
SmAttribute* at = op == OP_NEW_COLOR
? (SmAttribute*)new (ctx) SmColorAttribute((ULONG)a[1], v, (SmAttributeBehaviorType)a[2])
: (SmAttribute*)new (ctx) SmVector3dAttribute((ULONG)a[1], v, (SmAttributeBehaviorType)a[2]);
out.push_back(r.add_handle(at));
return 0;
}
case OP_NEW_TAG:
{
long t[8];
for (int i = 0; i < 8; ++i)
t[i] = (long)r.next_i();
if (r.bad_payload) return SC_ERR_ARG;
out.push_back(r.add_handle(new (ctx) SmTagAttribute((ULONG)a[1], t[0], t[1], t[2], t[3], t[4], t[5], t[6],
t[7], (SmAttributeBehaviorType)a[2])));
return 0;
}
case OP_SET_IS_VOID:
// SmRegion::SetIsVoid(TRUE / UNSURE / FALSE) on a script object.
if (!r.valid_obj(a[1]) || a[2] < 0 || a[2] > 2) return SC_ERR_ARG;
r.objs[(size_t)a[1]]->SetIsVoid((SmBoolean)a[2]);
return 0;
case OP_MAKE_INFINITE:
{
// Replace the object with the infinite region of a fresh B-rep, so
// IsInfiniteRegion()/GetBrep() are TRUE/non-NULL. Attributes created earlier
// keep pointing at the old object, so this is only defined before any
// attribute exists (the Rust runner applies the same rule).
if (!r.valid_obj(a[1])) return SC_ERR_ARG;
if (!r.handles.empty() || r.all.GetSize() > 0) return ST_SKIP;
SmBrep* brep = new (*r.ctx) SmBrep();
if (brep->GetInfiniteRegion() == nullptr) return SC_ERR_ARG;
r.objs[(size_t)a[1]] = brep->GetInfiniteRegion();
return 0;
}
case OP_NEW_MERGE_REGION:
if (!r.valid_obj(a[1]) || !r.valid_obj(a[3])) return SC_ERR_ARG;
out.push_back(r.add_handle(new (ctx) SmMergeRegionAttribute(r.objs[(size_t)a[1]], (ULONG)a[2],
r.objs[(size_t)a[3]], (ULONG)a[4])));
return 0;
case OP_READ_INDEXED:
{
if (!read_is_safe(r)) return ST_SKIP;
ULONG before = r.all.GetSize();
std::vector<SmAttribute*> old(before);
for (ULONG i = 0; i < before; ++i)
old[i] = r.all[i];
SmTArray<ULONG> idx;
SmStatus st = SmAttributeData::ReadIndexedAttributesFromDB(ctx, r.all, idx, *r.db);
// Placeholders created by this call become handles, in slot order.
r.all_handle.resize(r.all.GetSize(), -1);
for (ULONG i = 0; i < r.all.GetSize(); ++i)
if (r.all[i] != nullptr && (i >= before || old[i] == nullptr)) r.all_handle[i] = r.add_handle(r.all[i]);
if (st != SM_SUCCESS) return st;
for (ULONG i = 0; i < idx.GetSize(); ++i)
out.push_back((int64_t)idx[i]);
return 0;
}
case OP_FIND:
{
if (!r.valid_obj(a[1])) return SC_ERR_ARG;
SmAttribute* f = r.objs[(size_t)a[1]]->FindAttribute((ULONG)a[2]);
std::vector<SmAttribute*> l = r.list(a[1]);
int64_t pos = -1;
for (size_t i = 0; i < l.size() && f != nullptr; ++i)
if (l[i] == f)
{
pos = (int64_t)i;
break;
}
out.push_back(pos);
return 0;
}
case OP_CLEAR_ATTRIBUTES:
{
if (!r.valid_obj(a[1])) return SC_ERR_ARG;
// Predict deletions: per entry, users != 1 -> RemoveUser (never deletes under
// the invariant), users == 1 -> reset and delete unless standalone.
std::map<SmAttribute*, int64_t> count;
for (SmAttribute* x : r.list(a[1]))
{
if (!count.count(x)) count[x] = (int64_t)r.users(x).size();
int64_t& u = count[x];
if (u != 1)
--u;
else
{
u = 0;
if (!standalone(x)) r.mark_dead(x);
}
}
r.objs[(size_t)a[1]]->ClearAttributes();
return 0;
}
default:
break;
}
// Ops on an attribute reference (a[1]).
if (op == OP_ADD_ATTRIBUTE || op == OP_REMOVE_ATTRIBUTE)
{
if (!r.valid_obj(a[1])) return SC_ERR_ARG;
SmAttribute* at = r.resolve(a[2]);
if (at == nullptr) return ST_INVALID;
SmRegion* o = r.objs[(size_t)a[1]];
if (op == OP_ADD_ATTRIBUTE)
{
o->AddAttribute(at);
return 0;
}
std::vector<SmAttribute*> l = r.list(a[1]);
bool listed = false;
for (SmAttribute* x : l)
listed |= x == at;
if (listed && r.users(at).size() == 1 && a[3] == 0 && !standalone(at)) r.mark_dead(at);
o->RemoveAttribute(at, a[3] != 0 ? TRUE : FALSE);
return 0;
}
SmAttribute* at = r.resolve(a[1]);
if (at == nullptr) return ST_INVALID;
auto obj = [&](int64_t i) -> SmAObject* { return r.objs[(size_t)i]; };
switch (op)
{
case OP_MAKE_COPY:
out.push_back(r.add_handle(at->MakeCopy(ctx)));
return 0;
case OP_SPLIT:
if (!r.valid_obj(a[2]) || !r.valid_obj(a[3]) || !r.valid_obj(a[4])) return SC_ERR_ARG;
at->Split(obj(a[2]), obj(a[3]), obj(a[4]));
return 0;
case OP_COPY:
if (!r.valid_obj(a[2]) || !r.valid_obj(a[3])) return SC_ERR_ARG;
at->Copy(obj(a[2]), obj(a[3]));
return 0;
case OP_MERGE:
{
if (!r.valid_obj(a[2]) || !r.valid_obj(a[3]) || !r.valid_obj(a[4])) return SC_ERR_ARG;
if (kind_of(at) == K_MERGE_REGION)
{
SmAttribute* f[3] = {obj(a[4])->FindAttribute(SM_AI_OTHER_REGION_ID),
obj(a[2])->FindAttribute(SM_AI_OTHER_REGION_ID),
obj(a[3])->FindAttribute(SM_AI_OTHER_REGION_ID)};
for (SmAttribute* x : f)
if (x != nullptr && kind_of(x) != K_MERGE_REGION) return ST_SKIP;
if (f[1] != nullptr && f[2] != nullptr && f[0] == nullptr) return ST_SKIP;
}
at->Merge(obj(a[2]), obj(a[3]), obj(a[4]));
return 0;
}
case OP_COINCIDENT:
if (!r.valid_obj(a[2]) || !r.valid_obj(a[3])) return SC_ERR_ARG;
at->Coincident(obj(a[2]), obj(a[3]), nullptr, nullptr);
return 0;
case OP_EDIT:
if (!r.valid_obj(a[2])) return SC_ERR_ARG;
at->Edit(obj(a[2]));
return 0;
case OP_DESTRUCTION:
if (!r.valid_obj(a[2])) return SC_ERR_ARG;
at->Destruction(obj(a[2]));
return 0;
case OP_PROPAGATE:
{
if (!r.valid_obj(a[2]) || !r.valid_obj(a[3]) || !r.valid_obj(a[4])) return SC_ERR_ARG;
if (kind_of(at) == K_COLOR)
{
SmAttribute* c1 = obj(a[2])->FindAttribute(SM_AI_COLOR);
SmAttribute* c2 = obj(a[3])->FindAttribute(SM_AI_COLOR);
SmAttribute* cm = obj(a[4])->FindAttribute(SM_AI_COLOR);
if (c1 != nullptr && c2 != nullptr && (!is_vector(c1) || !is_vector(c2) || cm == nullptr || !is_vector(cm)))
return ST_SKIP;
}
at->PropagateRegionsThroughBooleans(obj(a[2]), obj(a[3]), obj(a[4]));
return 0;
}
case OP_ADD_USER:
if (!r.valid_obj(a[2])) return SC_ERR_ARG;
at->AddUser(obj(a[2]));
return 0;
case OP_REMOVE_USER:
case OP_FROM_CLEAR:
{
if (!r.valid_obj(a[2])) return SC_ERR_ARG;
if (r.listings(at) > 0) return ST_SKIP;
std::vector<SmAObject*> u = r.users(at);
bool found = false;
for (SmAObject* x : u)
found |= x == obj(a[2]);
if (op == OP_FROM_CLEAR && u.size() == 1)
{
if (!standalone(at)) r.mark_dead(at);
at->fromClearAttributes(obj(a[2]));
return 0;
}
bool dnd = op == OP_REMOVE_USER && a[3] != 0;
if (found && u.size() == 1 && !dnd && !standalone(at)) r.mark_dead(at);
if (op == OP_FROM_CLEAR)
at->fromClearAttributes(obj(a[2]));
else
at->RemoveUser(obj(a[2]), dnd ? TRUE : FALSE);
return 0;
}
case OP_GET_USERS:
for (SmAObject* x : r.users(at))
out.push_back(r.obj_index(x));
return 0;
case OP_QUERY:
{
out.push_back((int64_t)at->GetType());
int64_t mask = 0;
for (int i = 0; i < 11; ++i)
if (at->IsKindOf(QUERY_TYPES[i])) mask |= (int64_t)1 << i;
out.push_back(mask);
out.push_back(at->IsPropagatedThroughBooleans() ? 1 : 0);
out.push_back((int64_t)at->GetAttributeID());
out.push_back((int64_t)at->GetBehavior());
for (const TCHAR* s = at->GetTypeString(); *s; ++s)
out.push_back((int64_t)(unsigned char)*s);
return 0;
}
case OP_MR_QUERY:
{
if (kind_of(at) != K_MERGE_REGION) return ST_SKIP;
SmMergeRegionAttribute* m = (SmMergeRegionAttribute*)at;
out.push_back(m->HasThisInfiniteRegion() ? 1 : 0);
out.push_back(m->HasOtherInfiniteRegion() ? 1 : 0);
out.push_back(m->HasAnySolid((ULONG)a[2]) ? 1 : 0);
out.push_back((int64_t)m->GetOperation());
out.push_back(m->HasAnyOtherPropagatedAttribs() ? 1 : 0);
out.push_back((int64_t)m->GetThisRegions().GetSize());
out.push_back((int64_t)m->GetThisRegionTypes().GetSize());
out.push_back((int64_t)m->GetOtherRegions().GetSize());
if (m->GetThisRegions().GetSize() > 0) out.push_back(r.obj_index(m->GetThisRegion(0)));
return 0;
}
case OP_MR_SET_REGIONS:
{
if (kind_of(at) != K_MERGE_REGION) return ST_SKIP;
if (!r.valid_obj(a[3]) || !r.valid_obj(a[5])) return SC_ERR_ARG;
SmMergeRegionAttribute* m = (SmMergeRegionAttribute*)at;
ULONG idx = (ULONG)a[2];
if (idx < m->GetThisRegions().GetSize() &&
(idx >= m->GetThisRegionTypes().GetSize() || idx >= m->GetOtherRegions().GetSize() ||
idx >= m->GetOtherRegionTypes().GetSize()))
return ST_SKIP;
SmStatus st = m->SetRegions(idx, r.objs[(size_t)a[3]], (ULONG)a[4], r.objs[(size_t)a[5]], (ULONG)a[6]);
return st == SM_SUCCESS ? 0 : st;
}
case OP_MR_SET_OPERATION:
{
if (kind_of(at) != K_MERGE_REGION) return ST_SKIP;
((SmMergeRegionAttribute*)at)->SetOperation((SmBooleanOperationType)a[2]);
return 0;
}
case OP_SET_VECTOR:
{
double x = r.next_d(), y = r.next_d(), z = r.next_d();
if (r.bad_payload) return SC_ERR_ARG;
if (!is_vector(at)) return ST_SKIP;
SmVector3d v(x, y, z);
((SmVector3dAttribute*)at)->SetValue(v);
return 0;
}
case OP_DESTROY:
{
std::vector<SmAObject*> u = r.users(at);
if (!u.empty())
{
if (!standalone(at)) return ST_SKIP;
// users must equal listings (as multisets) so the destructor's loop
// unlinks every listing
std::map<const void*, int64_t> diff;
for (SmAObject* x : u)
diff[x] += 1;
for (size_t o = 0; o < r.objs.size(); ++o)
for (SmAttribute* x : r.list((int64_t)o))
if (x == at) diff[static_cast<SmAObject*>(r.objs[o])] -= 1;
for (auto& kv : diff)
if (kv.second != 0) return ST_SKIP;
}
r.mark_dead(at);
delete at;
return 0;
}
default:
return SC_ERR_ARG;
}
}
void dump(Run& r, std::vector<int64_t>& ints, std::vector<double>& dbls)
{
std::vector<SmAttribute*> canon;
std::map<SmAttribute*, int64_t> index;
auto visit = [&](SmAttribute* a) {
if (index.count(a)) return;
index[a] = (int64_t)canon.size();
canon.push_back(a);
};
for (size_t i = 0; i < r.handles.size(); ++i)
if (r.alive[i]) visit(r.handles[i]);
std::vector<std::vector<SmAttribute*>> lists;
for (size_t o = 0; o < r.objs.size(); ++o)
{
lists.push_back(r.list((int64_t)o));
for (SmAttribute* a : lists.back())
visit(a);
}
ints.push_back((int64_t)r.handles.size());
for (size_t i = 0; i < r.handles.size(); ++i)
ints.push_back(r.alive[i] ? 1 : 0);
for (size_t i = 0; i < r.handles.size(); ++i)
ints.push_back(r.alive[i] ? index[r.handles[i]] : -1);
ints.push_back((int64_t)canon.size());
for (SmAttribute* a : canon)
{
int64_t k = kind_of(a);
ints.push_back(k);
ints.push_back((int64_t)a->GetType());
ints.push_back((int64_t)a->GetAttributeID());
ints.push_back((int64_t)a->GetBehavior());
std::vector<SmAObject*> u = r.users(a);
ints.push_back((int64_t)u.size());
for (SmAObject* x : u)
ints.push_back(r.obj_index(x));
std::vector<int64_t> v;
std::vector<double> d;
switch (k)
{
case K_GENERIC:
{
SmGenericAttribute* g = (SmGenericAttribute*)a;
v.push_back((int64_t)g->GetLongTArray().GetSize());
for (ULONG i = 0; i < g->GetLongTArray().GetSize(); ++i)
v.push_back((int64_t)g->GetLongTArray()[i]);
v.push_back((int64_t)g->GetCharTArray().GetSize());
for (ULONG i = 0; i < g->GetCharTArray().GetSize(); ++i)
v.push_back((int64_t)(unsigned char)g->GetCharTArray()[i]);
for (ULONG i = 0; i < g->GetDoubleTArray().GetSize(); ++i)
d.push_back(g->GetDoubleTArray()[i]);
break;
}
case K_LONG:
v.push_back((int64_t)((SmLongAttribute*)a)->GetValue());
break;
case K_POINTER:
v.push_back((int64_t)(uintptr_t)((SmPointerAttribute*)a)->GetValue());
break;
case K_POINTER_LIST:
{
const SmTArray<SmObject*>& l = ((SmPointerListAttribute*)a)->GetValue();
v.push_back((int64_t)l.GetSize());
for (ULONG i = 0; i < l.GetSize(); ++i)
v.push_back((int64_t)(uintptr_t)l.GetAt(i));
break;
}
case K_VECTOR3D:
case K_COLOR:
{
const SmVector3d& x = ((SmVector3dAttribute*)a)->GetValue();
d.push_back(x.x);
d.push_back(x.y);
d.push_back(x.z);
break;
}
case K_MERGE_REGION:
{
SmMergeRegionAttribute* m = (SmMergeRegionAttribute*)a;
v.push_back((int64_t)m->GetOperation());
v.push_back((int64_t)m->GetThisRegions().GetSize());
for (ULONG i = 0; i < m->GetThisRegions().GetSize(); ++i)
v.push_back(r.obj_index(m->GetThisRegions()[i]));
v.push_back((int64_t)m->GetThisRegionTypes().GetSize());
for (ULONG i = 0; i < m->GetThisRegionTypes().GetSize(); ++i)
v.push_back((int64_t)m->GetThisRegionTypes()[i]);
v.push_back((int64_t)m->GetOtherRegions().GetSize());
for (ULONG i = 0; i < m->GetOtherRegions().GetSize(); ++i)
v.push_back(r.obj_index(m->GetOtherRegions()[i]));
v.push_back((int64_t)m->GetOtherRegionTypes().GetSize());
for (ULONG i = 0; i < m->GetOtherRegionTypes().GetSize(); ++i)
v.push_back((int64_t)m->GetOtherRegionTypes()[i]);
break;
}
case K_TAG:
{
SmTagAttribute* t = (SmTagAttribute*)a;
long f[8] = {t->m_lPrimaryID, t->m_lPrimaryOrdinal, t->m_lSecondaryIDType, t->m_lSecondaryID,
t->m_lSecondaryOrdinal, t->m_lThirdIDType, t->m_lThirdID, t->m_lThirdOrdinal};
for (long x : f)
v.push_back((int64_t)x);
break;
}
default:
break;
}
ints.push_back((int64_t)v.size());
ints.insert(ints.end(), v.begin(), v.end());
ints.push_back((int64_t)d.size());
dbls.insert(dbls.end(), d.begin(), d.end());
}
for (auto& l : lists)
{
ints.push_back((int64_t)l.size());
for (SmAttribute* a : l)
ints.push_back(index[a]);
}
ints.push_back((int64_t)r.all.GetSize());
for (ULONG i = 0; i < r.all.GetSize(); ++i)
ints.push_back(i < r.all_handle.size() ? r.all_handle[i] : -1);
std::istream* in = r.db ? r.db->GetInStreamPtr() : nullptr;
ints.push_back(in ? (int64_t)in->rdstate() : -1);
ints.push_back(in ? stream_pos(*in) : -1);
}
} // namespace
// n_objects: attributed objects; ops[7*n_ops]; payload_i / payload_d: creation data
// consumed in order; data/file_type/byte_swap: the stream of OP_READ_INDEXED
// (file_type < 0: no stream).
SC_EXPORT int32_t sc_geom_attribute_run(int64_t n_objects, const int64_t* ops, int64_t n_ops,
const int64_t* payload_i, int64_t n_payload_i, const double* payload_d,
int64_t n_payload_d, const uint8_t* data, int64_t data_len,
int32_t file_type, int32_t byte_swap, int64_t* ints, int64_t ints_cap,
int64_t* ints_len, double* dbls, int64_t dbls_cap, int64_t* dbls_len)
{
if (n_objects < 0 || n_objects > 64 || n_ops < 0 || n_payload_i < 0 || n_payload_d < 0 || data_len < 0 ||
file_type > 3)
return SC_ERR_ARG;
SC_TRY
Run r;
r.ctx = SmApiGetOrCreateContext();
if (r.ctx == nullptr) return SC_ERR_ARG;
for (int64_t i = 0; i < n_objects; ++i)
r.objs.push_back(new (*r.ctx) ShimRegion());
r.pay_i.assign(payload_i, payload_i + n_payload_i);
r.pay_d.assign(payload_d, payload_d + n_payload_d);
if (file_type >= 0)
{
r.data.assign((const char*)data, (size_t)data_len);
r.iss.reset(new std::istringstream(r.data));
r.db.reset(new SmDatabaseIOStream((SmFileType)file_type, r.iss.get()));
r.db->SetByteSwap(byte_swap != 0 ? TRUE : FALSE);
}
std::vector<int64_t> o_ints;
std::vector<double> o_dbls;
for (int64_t k = 0; k < n_ops; ++k)
{
const int64_t* a = ops + 7 * k;
if (a[0] < 0 || a[0] > OP_LAST) return SC_ERR_ARG;
std::vector<int64_t> out;
int64_t st = run_op(r, a, out);
if (st == SC_ERR_ARG) return SC_ERR_ARG;
o_ints.push_back(st);
o_ints.push_back((int64_t)out.size());
o_ints.insert(o_ints.end(), out.begin(), out.end());
}
dump(r, o_ints, o_dbls);
// Objects and surviving attributes are leaked on purpose: deleting a region runs
// its Notify/ClearAttributes chain, which is not what is being compared.
*ints_len = (int64_t)o_ints.size();
*dbls_len = (int64_t)o_dbls.size();
if (*ints_len > ints_cap || *dbls_len > dbls_cap) return SC_ERR_BUFFER;
for (size_t i = 0; i < o_ints.size(); ++i)
ints[i] = o_ints[i];
for (size_t i = 0; i < o_dbls.size(); ++i)
dbls[i] = o_dbls[i];
return SC_OK;
SC_CATCH
}
Reference in New Issue View Git Blame Copy Permalink