void spSlotData_setAttachmentName (spSlotData* self, const char* attachmentName) {
FREE(self->attachmentName);
if (attachmentName)
MALLOC_STR(self->attachmentName, attachmentName);
else
CONST_CAST(char*, self->attachmentName) = 0;
}
spIkConstraintData* spIkConstraintData_create (const char* name) {
spIkConstraintData* self = NEW(spIkConstraintData);
MALLOC_STR(self->name, name);
self->bendDirection = 1;
self->mix = 1;
return self;
}
_Entry* _Entry_create (int slotIndex, const char* name, spAttachment* attachment) {
_Entry* self = NEW(_Entry);
self->slotIndex = slotIndex;
MALLOC_STR(self->name, name);
self->attachment = attachment;
return self;
}
spAnimation* spAnimation_create (const char* name, int timelinesCount) {
spAnimation* self = NEW(spAnimation);
MALLOC_STR(self->name, name);
self->timelinesCount = timelinesCount;
self->timelines = MALLOC(spTimeline*, timelinesCount);
return self;
}
BoneData* BoneData_create (const char* name, BoneData* parent) {
BoneData* self = NEW(BoneData);
MALLOC_STR(self->name, name);
CONST_CAST(BoneData*, self->parent) = parent;
self->scaleX = 1;
self->scaleY = 1;
return self;
}
void _SkeletonJson_setError (SkeletonJson* self, Json* root, const char* value1, const char* value2) {
FREE(self->error);
char message[256];
strcpy(message, value1);
int length = strlen(value1);
if (value2) strncat(message + length, value2, 256 - length);
MALLOC_STR(self->error, message);
if (root) Json_dispose(root);
}
static const char *copyString(const char *src) {
if (src == NULL) {
return NULL;
}
const char *dest;
MALLOC_STR(dest, src);
return dest;
}
spSlotData* spSlotData_create (const char* name, spBoneData* boneData) {
spSlotData* self = NEW(spSlotData);
MALLOC_STR(self->name, name);
CONST_CAST(spBoneData*, self->boneData) = boneData;
self->r = 1;
self->g = 1;
self->b = 1;
self->a = 1;
return self;
}
spBoneData* spBoneData_create (int index, const char* name, spBoneData* parent) {
spBoneData* self = NEW(spBoneData);
CONST_CAST(int, self->index) = index;
MALLOC_STR(self->name, name);
CONST_CAST(spBoneData*, self->parent) = parent;
self->scaleX = 1;
self->scaleY = 1;
self->transformMode = SP_TRANSFORMMODE_NORMAL;
return self;
}
spBoneData* spBoneData_create (const char* name, spBoneData* parent) {
spBoneData* self = NEW(spBoneData);
MALLOC_STR(self->name, name);
CONST_CAST(spBoneData*, self->parent) = parent;
self->scaleX = 1;
self->scaleY = 1;
self->inheritScale = 1;
self->inheritRotation = 1;
return self;
}
/*-------------------------------------------------------------------------*
* PL_ATOM_CONCAT_ALT_0 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Atom_Concat_Alt_0(void)
{
WamWord atom1_word, atom2_word;
AtomInf *patom3;
char *name;
char *p;
char *str;
int l;
Pl_Update_Choice_Point((CodePtr) Prolog_Predicate(ATOM_CONCAT_ALT, 0), 0);
atom1_word = AB(B, 0);
atom2_word = AB(B, 1);
patom3 = (AtomInf *) AB(B, 2);
p = (char *) AB(B, 3);
if (*p == '\0')
Delete_Last_Choice_Point();
else /* non deterministic case */
{
#if 0 /* the following data is unchanged */
AB(B, 0) = atom1_word;
AB(B, 1) = atom2_word;
AB(B, 2) = (WamWord) patom3;
#endif
AB(B, 3) = (WamWord) (p + 1);
}
name = patom3->name;
l = p - name;
MALLOC_STR(l);
strncpy(str, name, l + 1);
str[l] = '\0';
if (!Pl_Get_Atom(Create_Malloc_Atom(str), atom1_word))
return FALSE;
l = patom3->prop.length - l;
MALLOC_STR(l);
strcpy(str, p);
return Pl_Get_Atom(Create_Malloc_Atom(str), atom2_word);
}
/*-------------------------------------------------------------------------*
* PL_SUB_ATOM_ALT_0 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Sub_Atom_Alt_0(void)
{
WamWord before_word, length_word, after_word, sub_atom_word;
AtomInf *patom;
AtomInf *psub_atom;
int b, l, a;
int b1, l1, a1;
int mask;
char *str;
Pl_Update_Choice_Point((CodePtr) Prolog_Predicate(SUB_ATOM_ALT, 0), 0);
before_word = AB(B, 0);
length_word = AB(B, 1);
after_word = AB(B, 2);
sub_atom_word = AB(B, 3);
patom = (AtomInf *) AB(B, 4);
psub_atom = (AtomInf *) AB(B, 5);
mask = AB(B, 6);
b = AB(B, 7);
l = AB(B, 8);
a = AB(B, 9);
if (!Compute_Next_BLA(mask, patom, psub_atom, b, l, a, &b1, &l1, &a1))
Delete_Last_Choice_Point();
else /* non deterministic case */
{
#if 0 /* the following data is unchanged */
AB(B, 0) = before_word;
AB(B, 1) = length_word;
AB(B, 2) = after_word;
AB(B, 3) = sub_atom_word;
AB(B, 4) = (WamWord) patom;
AB(B, 5) = (WamWord) psub_atom;
AB(B, 6) = mask;
#endif
AB(B, 7) = b1;
AB(B, 8) = l1;
AB(B, 9) = a1;
}
if (mask <= 7)
{
MALLOC_STR(l);
strncpy(str, patom->name + b, l);
str[l] = '\0';
Pl_Get_Atom(Create_Malloc_Atom(str), sub_atom_word);
Pl_Get_Integer(l, length_word);
}
return Pl_Get_Integer(b, before_word) && Pl_Get_Integer(a, after_word);
}
spSkin* spSkin_create (const char* name) {
spSkin* self = SUPER(NEW(_spSkin));
MALLOC_STR(self->name, name);
return self;
}
#include <spine/AttachmentLoader.h>
#include <spine/util.h>
void _AttachmentLoader_init (AttachmentLoader* self) {
}
void _AttachmentLoader_deinit (AttachmentLoader* self) {
FREE(self->error1)
FREE(self->error2)
}
void AttachmentLoader_dispose (AttachmentLoader* self) {
self->_dispose(self);
}
Attachment* AttachmentLoader_newAttachment (AttachmentLoader* self, AttachmentType type, const char* name) {
FREE(self->error1)
FREE(self->error2)
self->error1 = 0;
self->error2 = 0;
return self->_newAttachment(self, type, name);
}
void _AttachmentLoader_setError (AttachmentLoader* self, const char* error1, const char* error2) {
FREE(self->error1)
FREE(self->error2)
MALLOC_STR(self->error1, error1)
MALLOC_STR(self->error2, error2)
}
void _AttachmentLoader_setError (AttachmentLoader* self, const char* error1, const char* error2) {
FREE(self->error1);
FREE(self->error2);
MALLOC_STR(self->error1, error1);
MALLOC_STR(self->error2, error2);
}
spTransformConstraintData* spTransformConstraintData_create (const char* name) {
spTransformConstraintData* self = NEW(spTransformConstraintData);
MALLOC_STR(self->name, name);
return self;
}
/*-------------------------------------------------------------------------*
* PL_SUB_ATOM_5 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Sub_Atom_5(WamWord atom_word, WamWord before_word, WamWord length_word,
WamWord after_word, WamWord sub_atom_word)
{
WamWord word, tag_mask;
AtomInf *patom;
AtomInf *psub_atom = NULL; /* only for the compiler */
int length;
PlLong b, l, a;
int b1, l1, a1;
Bool nondet;
int mask = 0;
char *str;
patom = pl_atom_tbl + Pl_Rd_Atom_Check(atom_word);
length = patom->prop.length;
DEREF_LG(before_word, b);
DEREF_LG(length_word, l);
DEREF_LG(after_word, a);
DEREF(sub_atom_word, word, tag_mask);
if (tag_mask != TAG_REF_MASK && tag_mask != TAG_ATM_MASK)
Pl_Err_Type(pl_type_atom, word);
sub_atom_word = word;
if (tag_mask == TAG_ATM_MASK)
{
psub_atom = pl_atom_tbl + UnTag_ATM(word);
l = psub_atom->prop.length;
if (!Pl_Get_Integer(l, length_word))
return FALSE;
if ((mask & 5) == 5 && length != b + l + a) /* B and A fixed */
return FALSE;
if (mask & 4) /* B fixed */
{
a = length - b - l;
return strncmp(patom->name + b, psub_atom->name, l) == 0 &&
Pl_Get_Integer(a, after_word);
}
if (mask & 1) /* A fixed */
{
b = length - l - a;
return strncmp(patom->name + b, psub_atom->name, l) == 0 &&
Pl_Get_Integer(b, before_word);
}
mask = 8; /* set sub_atom as fixed */
}
switch (mask) /* mask <= 7, B L A (1: fixed, 0: var) */
{
case 0: /* nothing fixed */
case 2: /* L fixed */
case 4: /* B fixed */
a = length - b - l;
nondet = TRUE;
break;
case 1: /* A fixed */
l = length - b - a;
nondet = TRUE;
break;
case 3: /* L A fixed */
b = length - l - a;
nondet = FALSE;
break;
case 5: /* B A fixed */
l = length - b - a;
nondet = FALSE;
break;
case 6: /* B L fixed */
case 7: /* B L A fixed */
a = length - b - l;
nondet = FALSE;
break;
default: /* sub_atom fixed */
if ((str = strstr(patom->name + b, psub_atom->name)) == NULL)
return FALSE;
b = str - patom->name;
a = length - b - l;
nondet = TRUE;
break;
}
if (b < 0 || l < 0 || a < 0)
return FALSE;
if (nondet
&& Compute_Next_BLA(mask, patom, psub_atom, b, l, a, &b1, &l1, &a1))
{ /* non deterministic case */
A(0) = before_word;
A(1) = length_word;
A(2) = after_word;
A(3) = sub_atom_word;
A(4) = (WamWord) patom;
A(5) = (WamWord) psub_atom;
A(6) = mask;
A(7) = b1;
A(8) = l1;
A(9) = a1;
Pl_Create_Choice_Point((CodePtr) Prolog_Predicate(SUB_ATOM_ALT, 0), 10);
}
if (mask <= 7)
{
MALLOC_STR(l);
strncpy(str, patom->name + b, l);
str[l] = '\0';
Pl_Get_Atom(Create_Malloc_Atom(str), sub_atom_word);
Pl_Get_Integer(l, length_word);
}
return Pl_Get_Integer(b, before_word) && Pl_Get_Integer(a, after_word);
}
Skin* Skin_create (const char* name) {
Skin* self = SUPER(NEW(_Internal));
MALLOC_STR(self->name, name);
return self;
}
spEventData* spEventData_create (const char* name) {
spEventData* self = NEW(spEventData);
MALLOC_STR(self->name, name);
return self;
}
/*-------------------------------------------------------------------------*
* PL_ATOM_CONCAT_3 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Atom_Concat_3(WamWord atom1_word, WamWord atom2_word, WamWord atom3_word)
{
WamWord word, tag_mask;
int tag1, tag2, tag3;
AtomInf *patom1, *patom2, *patom3;
char *str;
int l;
DEREF(atom1_word, word, tag_mask);
if (tag_mask != TAG_REF_MASK && tag_mask != TAG_ATM_MASK)
Pl_Err_Type(pl_type_atom, atom1_word);
tag1 = tag_mask;
atom1_word = word;
DEREF(atom2_word, word, tag_mask);
if (tag_mask != TAG_REF_MASK && tag_mask != TAG_ATM_MASK)
Pl_Err_Type(pl_type_atom, atom2_word);
tag2 = tag_mask;
atom2_word = word;
DEREF(atom3_word, word, tag_mask);
if (tag_mask != TAG_REF_MASK && tag_mask != TAG_ATM_MASK)
Pl_Err_Type(pl_type_atom, atom3_word);
tag3 = tag_mask;
atom3_word = word;
if (tag3 == TAG_REF_MASK && (tag1 == TAG_REF_MASK || tag2 == TAG_REF_MASK))
Pl_Err_Instantiation();
if (tag1 == TAG_ATM_MASK)
{
patom1 = pl_atom_tbl + UnTag_ATM(atom1_word);
if (tag2 == TAG_ATM_MASK)
{
patom2 = pl_atom_tbl + UnTag_ATM(atom2_word);
l = patom1->prop.length + patom2->prop.length;
MALLOC_STR(l);
strcpy(str, patom1->name);
strcpy(str + patom1->prop.length, patom2->name);
return Pl_Get_Atom(Create_Malloc_Atom(str), atom3_word);
}
patom3 = pl_atom_tbl + UnTag_ATM(atom3_word);
l = patom3->prop.length - patom1->prop.length;
if (l < 0 || strncmp(patom1->name, patom3->name, patom1->prop.length) != 0)
return FALSE;
MALLOC_STR(l);
strcpy(str, patom3->name + patom1->prop.length);
return Pl_Get_Atom(Create_Malloc_Atom(str), atom2_word);
}
if (tag2 == TAG_ATM_MASK) /* here tag1 == REF */
{
patom2 = pl_atom_tbl + UnTag_ATM(atom2_word);
patom3 = pl_atom_tbl + UnTag_ATM(atom3_word);
l = patom3->prop.length - patom2->prop.length;
if (l < 0 || strncmp(patom2->name, patom3->name + l, patom2->prop.length) != 0)
return FALSE;
MALLOC_STR(l);
strncpy(str, patom3->name, l);
str[l] = '\0';
return Pl_Get_Atom(Create_Malloc_Atom(str), atom1_word);
}
/* A1 and A2 are variables: non deterministic case */
patom3 = pl_atom_tbl + UnTag_ATM(atom3_word);
if (patom3->prop.length > 0)
{
A(0) = atom1_word;
A(1) = atom2_word;
A(2) = (WamWord) patom3;
A(3) = (WamWord) (patom3->name + 1);
Pl_Create_Choice_Point((CodePtr) Prolog_Predicate(ATOM_CONCAT_ALT, 0), 4);
}
return Pl_Get_Atom(pl_atom_void, atom1_word) &&
Pl_Get_Atom_Tagged(atom3_word, atom2_word);
}