Thread overview
Linker error
Oct 12
jfondren
Oct 12
bauss
October 11

So, I have the following two files:

skeleton.d:

/*skeleton.d by Ruby The Roobster*/
/*Version 1.0 Release*/
/*Module for representing skeletons in the D Programming Language 2.0*/
/*This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.*/
/** Copyright: 2021, Ruby The Roobster*/
/**Author: Ruby The Roobster, michaeleverestc79@gmail.com*/
/**Date: October 1, 2021*/
/** License:  GPL-3.0*/
module dutils.skeleton;
/**Struct for representing a point.*/
public struct Point	{ //Point structure...
	///Point.x is the 'x' coordinate of the point.
	real x;
	///Point.y is the 'y' coordinate of the point.
	real y;
	///Point.z is the 'z' coordinate of the point.
	real z;
	void opAssign(Point rhs)	{
		this.x = rhs.x;
		this.y = rhs.y;
		this.z = rhs.z;
	}
	void opOpAssign(string op)(Point rhs)	{
		mixin("this.x " ~ op ~ "= rhs.x;");
		mixin("this.y " ~ op ~ "= rhs.y;");
		mixin("this.z " ~ op ~ "= rhs.z;");
	}
}
/**Struct for representing a face of a skeleton that is made out of lines.*/
public struct Face	{ //Face(of a 3D shape) structure...
	///Face.lines is an array of all the lines that connect to form the face.
	Line[] lines;
	///Face.center is the center point of the face.
	Point center;
	void opAssign(Face rhs)	{
		this.lines.length = rhs.lines.length;
		foreach(i;0 .. this.lines.length)	{
			this.lines[i] = rhs.lines[i];
		}
	}
}
/**Struct for representing a 3D skeleton.*/
public struct Skeleton	{ //Skeleton of a 3D structure...
	///Skeleton.faces is an array of the faces that make up the Skeleton.
	Face[] faces;
	///Skeleton.center is the center point of the skeleton.
	Point center;
	void opAssign(Skeleton rhs)	{
		this.faces.length = rhs.faces.length;
		foreach(i;0 .. this.faces.length)	{
			this.faces[i] = rhs.faces[i];
		}
		this.center = rhs.center;
	}
}

/**Struct for representing a line composed of at least a starting point and an end point.
  *Notes:
  *This struct doesn't check to make sure that the line made is an actual line and assumes the user knows what they are doing.
*/
public struct Line	{ //Line struct...
	///Line.mid_points is an array containing all of the points that are neither start nor end points.
	Point[] mid_points;
	///Line.start is the start point of the line.
	Point start;
	///Line.end is the end point of the line.
	Point stop;
	void opAssign(Line rhs)	{
		this.start = rhs.start;
		this.stop = rhs.stop;
		this.mid_points.length = rhs.mid_points.length;
		foreach(i;0 .. this.mid_points.length)	{
			this.mid_points[i] = rhs.mid_points[i];
		}
	}
}

physics.d:

/*physics.d by Ruby The Roobster*/
/*Version 0.35 testing*/
/*Module for basic physics in the D Programming Language 2.0*/
/*This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.*/
/** Copyright: 2021, Ruby The Roobster*/
/**Author: Ruby The Roobster, michaeleverestc79@gmail.com*/
/**Date: October 11, 2021*/
/** License: GPL-3.0*/
module dutils.physics;
public import dutils.skeleton;

package mixin template move__()	{
	pragma(inline) package void mv(Point moveby, ref Skeleton tomove)	{
		foreach(i;tomove.faces)	{
			foreach(k;i.lines)	{
				foreach(j;k.mid_points)	{
					j += moveby;
				}
				k.start += moveby;
				k.stop += moveby;
			}
			i.center += moveby;
		}
		tomove.center += moveby;
	}
}
/**
  * move moves all the points in a skeleton to a specified point with a specified time gap between moving the points.
  * Params:
  * moveto=	A point specifying the total amount to move along each axis.
  * tbf=	The time in miliseconds between 'frames'(a frame is one section of moving points before waiting a bit).  This gives an illusion of continuous motion.
  * tomove=	The skeleton being moved.
  * speed=	The speed at which to move the points.
  * Returns:
  * none
*/
public void move(Point moveto, uint tbf, ref Skeleton tomove, real speed)	{
	import core.thread;
	mixin move__;
	Point moveby;
	moveby.x = moveto.x / speed;
	moveby.y = moveto.y / speed;
	moveby.z = moveto.z / speed;
	while(!((tomove.center.x > moveto.x && moveto.x > 0) ^ (tomove.center.x < moveto.x && moveto.x < 0)))	{
		mv(moveby, tomove);
		debug import std.stdio : writeln;
		debug writeln(tomove.center);
		Thread.sleep(dur!"msecs"(tbf));
	}
	foreach(i;tomove.faces)	{
		foreach(j;i.lines)	{
			foreach(k;j.mid_points)	{
				k += moveto;
			}
			j.start += moveto;
			j.stop += moveto;
		}
		i.center += moveto;
	}
	tomove.center += moveto;
	debug import std.stdio : writeln;
	debug writeln(tomove.center);
}

public void accMove()	{
}

public void decMove()	{
}

Now, here is a test file I am using to test the 'move()' function in physics.d:

import dutils.physics;
void main()	{
	Skeleton skele = Skeleton([Face([Line(new Point[0],Point(0,0,0),Point(0,0,0))],Point(0,0,0))],Point(0,0,0));
	move(Point(1,1,1),10, skele, 0.01);
}

And here is the error I am getting from the linker(optlink):

Error 42: Symbol Undefined __D6dutils7physics4moveFSQw8skeleton5PointkKSQBqQv8SkeletoneZ8__mixin52mvMFNaNbNiNfQChKQBrZv

The command line is as follows(tst.d is the name of my test file, and the other files are in the same directory):

dmd tst.d physics.d skeleton.d -debug

Compiler is dmd 2.098.0.
Thanks in advance.

October 12

On Monday, 11 October 2021 at 23:43:17 UTC, Ruby The Roobster wrote:

>

package mixin template move__() {
pragma(inline) package void mv(Point moveby, ref Skeleton tomove) {
foreach(i;tomove.faces) {
foreach(k;i.lines) {
foreach(j;k.mid_points) {
j += moveby;
}
k.start += moveby;
k.stop += moveby;
}
i.center += moveby;
}
tomove.center += moveby;
}
}

It compiles if this pragma(inline) is removed.

October 12

On Tuesday, 12 October 2021 at 00:01:25 UTC, jfondren wrote:

>

On Monday, 11 October 2021 at 23:43:17 UTC, Ruby The Roobster wrote:

>

package mixin template move__() {
pragma(inline) package void mv(Point moveby, ref Skeleton tomove) {
foreach(i;tomove.faces) {
foreach(k;i.lines) {
foreach(j;k.mid_points) {
j += moveby;
}
k.start += moveby;
k.stop += moveby;
}
i.center += moveby;
}
tomove.center += moveby;
}
}

It compiles if this pragma(inline) is removed.

Not to mention there is no point in marking mv with either pragma(inline) or package.

It's mixed into the function move(), which means it cannot be accessed outside of the function anyway, so that makes package unnecessary.

Inline will probably do nothing as the inline really just tells the compiler it should inline if it can or wants to, it's not a guarantee and it probably can't inline the function in this case.