INT NS_PREFIX InitLow ()
{
INT err;
char buffer[BUFFSIZE];
/* init heaps.c */
if ((err=InitHeaps())!=0)
{
SetHiWrd(err,__LINE__);
return (err);
}
/* init ugenv.c */
if ((err=InitUgEnv())!=0)
{
SetHiWrd(err,__LINE__);
return (err);
}
/* init fileopen */
if ((err=InitFileOpen())!=0)
{
SetHiWrd(err,__LINE__);
return (err);
}
/* init structs */
if ((err=InitUgStruct())!=0)
{
SetHiWrd(err,__LINE__);
return (err);
}
return (0);
}
void Slvs_Solve(Slvs_System *ssys, Slvs_hGroup shg)
{
if(!IsInit) {
InitHeaps();
IsInit = 1;
}
int i;
for(i = 0; i < ssys->params; i++) {
Slvs_Param *sp = &(ssys->param[i]);
Param p;
ZERO(&p);
p.h.v = sp->h;
p.val = sp->val;
SK.param.Add(&p);
if(sp->group == shg) {
SYS.param.Add(&p);
}
}
for(i = 0; i < ssys->entities; i++) {
Slvs_Entity *se = &(ssys->entity[i]);
EntityBase e;
ZERO(&e);
switch(se->type) {
case SLVS_E_POINT_IN_3D: e.type = Entity::POINT_IN_3D; break;
case SLVS_E_POINT_IN_2D: e.type = Entity::POINT_IN_2D; break;
case SLVS_E_NORMAL_IN_3D: e.type = Entity::NORMAL_IN_3D; break;
case SLVS_E_NORMAL_IN_2D: e.type = Entity::NORMAL_IN_2D; break;
case SLVS_E_DISTANCE: e.type = Entity::DISTANCE; break;
case SLVS_E_WORKPLANE: e.type = Entity::WORKPLANE; break;
case SLVS_E_LINE_SEGMENT: e.type = Entity::LINE_SEGMENT; break;
case SLVS_E_CUBIC: e.type = Entity::CUBIC; break;
case SLVS_E_CIRCLE: e.type = Entity::CIRCLE; break;
case SLVS_E_ARC_OF_CIRCLE: e.type = Entity::ARC_OF_CIRCLE; break;
default: dbp("bad entity type %d", se->type); return;
}
e.h.v = se->h;
e.group.v = se->group;
e.workplane.v = se->wrkpl;
e.point[0].v = se->point[0];
e.point[1].v = se->point[1];
e.point[2].v = se->point[2];
e.point[3].v = se->point[3];
e.normal.v = se->normal;
e.distance.v = se->distance;
e.param[0].v = se->param[0];
e.param[1].v = se->param[1];
e.param[2].v = se->param[2];
e.param[3].v = se->param[3];
SK.entity.Add(&e);
}
for(i = 0; i < ssys->constraints; i++) {
Slvs_Constraint *sc = &(ssys->constraint[i]);
ConstraintBase c;
ZERO(&c);
int t;
switch(sc->type) {
case SLVS_C_POINTS_COINCIDENT: t = Constraint::POINTS_COINCIDENT; break;
case SLVS_C_PT_PT_DISTANCE: t = Constraint::PT_PT_DISTANCE; break;
case SLVS_C_PT_PLANE_DISTANCE: t = Constraint::PT_PLANE_DISTANCE; break;
case SLVS_C_PT_LINE_DISTANCE: t = Constraint::PT_LINE_DISTANCE; break;
case SLVS_C_PT_FACE_DISTANCE: t = Constraint::PT_FACE_DISTANCE; break;
case SLVS_C_PT_IN_PLANE: t = Constraint::PT_IN_PLANE; break;
case SLVS_C_PT_ON_LINE: t = Constraint::PT_ON_LINE; break;
case SLVS_C_PT_ON_FACE: t = Constraint::PT_ON_FACE; break;
case SLVS_C_EQUAL_LENGTH_LINES: t = Constraint::EQUAL_LENGTH_LINES; break;
case SLVS_C_LENGTH_RATIO: t = Constraint::LENGTH_RATIO; break;
case SLVS_C_EQ_LEN_PT_LINE_D: t = Constraint::EQ_LEN_PT_LINE_D; break;
case SLVS_C_EQ_PT_LN_DISTANCES: t = Constraint::EQ_PT_LN_DISTANCES; break;
case SLVS_C_EQUAL_ANGLE: t = Constraint::EQUAL_ANGLE; break;
case SLVS_C_EQUAL_LINE_ARC_LEN: t = Constraint::EQUAL_LINE_ARC_LEN; break;
case SLVS_C_SYMMETRIC: t = Constraint::SYMMETRIC; break;
case SLVS_C_SYMMETRIC_HORIZ: t = Constraint::SYMMETRIC_HORIZ; break;
case SLVS_C_SYMMETRIC_VERT: t = Constraint::SYMMETRIC_VERT; break;
case SLVS_C_SYMMETRIC_LINE: t = Constraint::SYMMETRIC_LINE; break;
case SLVS_C_AT_MIDPOINT: t = Constraint::AT_MIDPOINT; break;
case SLVS_C_HORIZONTAL: t = Constraint::HORIZONTAL; break;
case SLVS_C_VERTICAL: t = Constraint::VERTICAL; break;
case SLVS_C_DIAMETER: t = Constraint::DIAMETER; break;
case SLVS_C_PT_ON_CIRCLE: t = Constraint::PT_ON_CIRCLE; break;
case SLVS_C_SAME_ORIENTATION: t = Constraint::SAME_ORIENTATION; break;
case SLVS_C_ANGLE: t = Constraint::ANGLE; break;
case SLVS_C_PARALLEL: t = Constraint::PARALLEL; break;
case SLVS_C_PERPENDICULAR: t = Constraint::PERPENDICULAR; break;
case SLVS_C_ARC_LINE_TANGENT: t = Constraint::ARC_LINE_TANGENT; break;
case SLVS_C_CUBIC_LINE_TANGENT: t = Constraint::CUBIC_LINE_TANGENT; break;
case SLVS_C_EQUAL_RADIUS: t = Constraint::EQUAL_RADIUS; break;
case SLVS_C_PROJ_PT_DISTANCE: t = Constraint::PROJ_PT_DISTANCE; break;
case SLVS_C_WHERE_DRAGGED: t = Constraint::WHERE_DRAGGED; break;
case SLVS_C_CURVE_CURVE_TANGENT:t = Constraint::CURVE_CURVE_TANGENT; break;
default: dbp("bad constraint type %d", sc->type); return;
}
c.type = t;
c.h.v = sc->h;
c.group.v = sc->group;
c.workplane.v = sc->wrkpl;
c.valA = sc->valA;
c.ptA.v = sc->ptA;
c.ptB.v = sc->ptB;
c.entityA.v = sc->entityA;
c.entityB.v = sc->entityB;
c.entityC.v = sc->entityC;
c.entityD.v = sc->entityD;
c.other = (sc->other) ? true : false;
c.other2 = (sc->other2) ? true : false;
SK.constraint.Add(&c);
}
for(i = 0; i < (int)arraylen(ssys->dragged); i++) {
if(ssys->dragged[i]) {
hParam hp = { ssys->dragged[i] };
SYS.dragged.Add(&hp);
}
}
Group g;
ZERO(&g);
g.h.v = shg;
List<hConstraint> bad;
ZERO(&bad);
// Now we're finally ready to solve!
bool andFindBad = ssys->calculateFaileds ? true : false;
int how = SYS.Solve(&g, &(ssys->dof), &bad, andFindBad, false);
switch(how) {
case System::SOLVED_OKAY:
ssys->result = SLVS_RESULT_OKAY;
break;
case System::DIDNT_CONVERGE:
ssys->result = SLVS_RESULT_DIDNT_CONVERGE;
break;
case System::SINGULAR_JACOBIAN:
ssys->result = SLVS_RESULT_INCONSISTENT;
break;
case System::TOO_MANY_UNKNOWNS:
ssys->result = SLVS_RESULT_TOO_MANY_UNKNOWNS;
break;
default: oops();
}
// Write the new parameter values back to our caller.
for(i = 0; i < ssys->params; i++) {
Slvs_Param *sp = &(ssys->param[i]);
hParam hp = { sp->h };
sp->val = SK.GetParam(hp)->val;
}
if(ssys->failed) {
// Copy over any the list of problematic constraints.
for(i = 0; i < ssys->faileds && i < bad.n; i++) {
ssys->failed[i] = bad.elem[i].v;
}
ssys->faileds = bad.n;
}
bad.Clear();
SYS.param.Clear();
SYS.entity.Clear();
SYS.eq.Clear();
SYS.dragged.Clear();
SK.param.Clear();
SK.entity.Clear();
SK.constraint.Clear();
FreeAllTemporary();
}
int main(int argc, char *argv[])
{
#if !defined DEBUGMODE && !defined DAEMONTOOLS
pid_t pid; /* pid of this process */
#endif /* !DEBUGMODE && !DAEMONTOOLS */
#ifdef GDB_DEBUG
int GDBAttached = 0;
#endif /* GDB_DEBUG */
#if defined GIMMECORE || defined DEBUGMODE
struct rlimit rlim; /* resource limits -kre */
#endif /* GIMMECORE || DEBUGMODE */
FILE *pidfile; /* to write our pid */
uid_t uid; /* real user id */
uid_t euid; /* effective user id */
#if defined HAVE_BOEHM_GC
GC_INIT();
#endif /* HAVE_BOEHM_GC */
myargv = argv;
/* Initialise current TS for services -kre */
TimeStarted = current_ts = time(NULL);
/* Be sure, be paranoid, be safe. -kre */
umask(077);
fprintf(stderr,
"Hybserv2 TS services version %s by Hybserv2 team\n"
#if defined __DATE__ && defined __TIME__
"Compiled at %s, %s\n",
#endif
hVersion
#if defined __DATE__ && defined __TIME__
, __DATE__, __TIME__
#endif
);
#ifdef GDB_DEBUG
while (!GDBAttached)
sleep(1);
#endif /* GDB_DEBUG */
/*
* Load SETPATH (settings.conf) - this must be done
* before the config file is loaded, and before any
* putlog() calls are made, since LogFile is specified
* in settings.conf
*/
if (LoadSettings(0) == 0)
{
fprintf(stderr, "Fatal errors encountered parsing %s, exiting\n"
"Check logfile %s/%s\n", SETPATH, LogPath ? LogPath : "",
LogFile ? LogFile : "*unknown*");
return (0);
}
/*
* If they run ./shownicks or ./showchans rather than ./hybserv
* display nicknames/channels
*/
if (strstr(argv[0], "shownicks"))
{
#ifdef NICKSERVICES
ShowNicknames(argc, argv);
#endif /* NICKSERVICES */
return (0);
}
else if (strstr(argv[0], "showchans"))
{
#if defined(NICKSERVICES) && defined(CHANNELSERVICES)
ShowChannels(argc, argv);
#endif /* defined(NICKSERVICES) && defined(CHANNELSERVICES) */
return 0;
}
/* Check for running services -kre */
if ((pidfile = fopen(PidFile, "r")) == NULL)
fprintf(stderr, "WARNING: Unable to read pid file %s\n",
PidFile);
else
{
pid_t mypid;
char line[MAXLINE + 1];
if (fgets(line, sizeof(line), pidfile) != NULL)
{
mypid = atoi(line);
if (mypid && !kill(mypid, 0))
{
fprintf(stderr, "FATAL: Services are already running!\n");
fclose(pidfile);
exit(EXIT_FAILURE);
}
}
fclose(pidfile);
}
uid = getuid(); /* the user id of the user who ran the process */
euid = geteuid(); /* the effective id (different if setuid) */
if (!uid || !euid)
{
fprintf(stderr,
"FATAL: Please don't run services as root. Now exiting.\n");
exit(EXIT_FAILURE);
}
if (chdir(HPath) != 0)
{
fprintf(stderr,
"HPath is an invalid directory, please check %s\n",
SETPATH);
exit(EXIT_FAILURE);
}
putlog(LOG1, "Hybserv2 TS services version %s started", hVersion);
/* Get the offset from GMT (London time) */
gmt_offset = GetTZOffset(TimeStarted);
/*
* the Network list must be initialized before the config
* file is loaded
*/
InitLists();
/* load server, jupe, gline, user, admin info */
LoadConfig();
/* load nick/chan/memo/stat databases */
LoadData();
#ifdef GLOBALSERVICES
if (LogonNews)
{
Network->LogonNewsFile.filename = LogonNews;
ReadMessageFile(&Network->LogonNewsFile);
}
#endif /* GLOBALSERVICES */
if (LocalHostName)
SetupVirtualHost();
#if !defined DEBUGMODE && !defined GDB_DEBUG
/* Daemontools compatibility stuff */
#ifndef DAEMONTOOLS
pid = fork();
if (pid == -1)
{
printf("Unable to fork(), exiting.\n");
exit(EXIT_FAILURE);
}
if (pid != 0)
{
printf("Running in background (pid: %d)\n", (int)pid);
exit(EXIT_SUCCESS);
}
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
/* Make current process session leader -kre */
if (setsid() == -1)
{
exit(EXIT_FAILURE);
}
#else
printf("Entering foreground debug mode\n");
#endif /* DEBUGMODE */
#endif /* DAEMONTOOLS */
#if defined GIMMECORE || defined DEBUGMODE
printf("Setting corefile limit... ");
/* Set corefilesize to maximum - therefore we ensure that core will be
* generated, no matter of shell limits -kre */
getrlimit(RLIMIT_CORE, &rlim);
rlim.rlim_cur = rlim.rlim_max;
setrlimit(RLIMIT_CORE, &rlim);
printf("done.\n");
#endif /* GIMMECORE || DEBUGMODE */
/* Signals must be set up after fork(), since the parent exits */
InitSignals();
/* Initialise random number generator -kre */
srandom(current_ts);
srandom((unsigned int)random());
/* Write our pid to a file */
if ((pidfile = fopen(PidFile, "w")) == NULL)
putlog(LOG1, "Unable to open %s", PidFile);
else
{
char line[MAXLINE + 1];
ircsprintf(line, "%d\n", getpid());
fputs(line, pidfile);
fclose(pidfile);
}
/* initialize tcm/user listening ports */
InitListenPorts();
/* initialize hash tables */
ClearHashes(1);
#ifdef BLOCK_ALLOCATION
InitHeaps();
#endif
HubSock = NOSOCKET;
CycleServers();
while (1)
{
/* enter loop waiting for server info */
ReadSocketInfo();
if (Me.hub)
SendUmode(OPERUMODE_Y, "*** Disconnected from %s", Me.hub->name);
else
SendUmode(OPERUMODE_Y, "*** Disconnected from hub server");
if (currenthub)
{
if (currenthub->realname)
{
MyFree(currenthub->realname);
currenthub->realname = NULL;
}
currenthub->connect_ts = 0;
}
close(HubSock); /* There was an error */
HubSock = NOSOCKET;
/*
* whenever Hybserv connects/reconnects to a server, clear
* users, servers, and chans
*/
ClearUsers();
ClearChans();
ClearServs();
/*
* ClearHashes() must be called AFTER ClearUsers(),
* or StatServ's unique client counts will be off since
* cloneTable[] would be NULL while it was trying to find
* clones
*/
ClearHashes(0);
PostCleanup();
} /* while (1) */
return 0;
} /* main() */
//-----------------------------------------------------------------------------
// Entry point into the program.
//-----------------------------------------------------------------------------
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, INT nCmdShow)
{
Instance = hInstance;
InitCommonControls();
// A monospaced font
FixedFont = CreateFont(SS.TW.CHAR_HEIGHT, SS.TW.CHAR_WIDTH, 0, 0,
FW_REGULAR, false,
false, false, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
DEFAULT_QUALITY, FF_DONTCARE, "Lucida Console");
if(!FixedFont)
FixedFont = (HFONT)GetStockObject(SYSTEM_FONT);
// Create the root windows: one for control, with text, and one for
// the graphics
CreateMainWindows();
ThawWindowPos(TextWnd);
ThawWindowPos(GraphicsWnd);
ShowWindow(TextWnd, SW_SHOWNOACTIVATE);
ShowWindow(GraphicsWnd, SW_SHOW);
glClearColor(0, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
SwapBuffers(GetDC(GraphicsWnd));
glClearColor(0, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
SwapBuffers(GetDC(GraphicsWnd));
// Create the heaps for all dynamic memory (AllocTemporary, MemAlloc)
InitHeaps();
// A filename may have been specified on the command line; if so, then
// strip any quotation marks, and make it absolute.
char file[MAX_PATH] = "";
if(strlen(lpCmdLine)+1 < MAX_PATH) {
char *s = lpCmdLine;
while(*s == ' ' || *s == '"') s++;
strcpy(file, s);
s = strrchr(file, '"');
if(s) *s = '\0';
}
if(*file != '\0') {
GetAbsoluteFilename(file);
}
#ifdef HAVE_SPACEWARE
// Initialize the SpaceBall, if present. Test if the driver is running
// first, to avoid a long timeout if it's not.
HWND swdc = FindWindow("SpaceWare Driver Class", NULL);
if(swdc != NULL) {
SiOpenData sod;
SiInitialize();
SiOpenWinInit(&sod, GraphicsWnd);
SpaceNavigator =
SiOpen("GraphicsWnd", SI_ANY_DEVICE, SI_NO_MASK, SI_EVENT, &sod);
SiSetUiMode(SpaceNavigator, SI_UI_NO_CONTROLS);
}
#endif
// Call in to the platform-independent code, and let them do their init
SS.Init();
if(strcmp(file, ""))
SS.OpenFile(file);
// And now it's the message loop. All calls in to the rest of the code
// will be from the wndprocs.
MSG msg;
DWORD ret;
while((ret = GetMessage(&msg, NULL, 0, 0)) != 0) {
#ifdef HAVE_SPACEWARE
// Is it a message from the six degree of freedom input device?
if(ProcessSpaceNavigatorMsg(&msg)) goto done;
#endif
// A message from the keyboard, which should be processed as a keyboard
// accelerator?
if(msg.message == WM_KEYDOWN) {
if(ProcessKeyDown(msg.wParam)) goto done;
}
if(msg.message == WM_SYSKEYDOWN && msg.hwnd == TextWnd) {
// If the user presses the Alt key when the text window has focus,
// then that should probably go to the graphics window instead.
SetForegroundWindow(GraphicsWnd);
}
// None of the above; so just a normal message to process.
TranslateMessage(&msg);
DispatchMessage(&msg);
done:
SS.DoLater();
}
#ifdef HAVE_SPACEWARE
if(swdc != NULL) {
if(SpaceNavigator != SI_NO_HANDLE) SiClose(SpaceNavigator);
SiTerminate();
}
#endif
// Write everything back to the registry
FreezeWindowPos(TextWnd);
FreezeWindowPos(GraphicsWnd);
// Free the memory we've used; anything that remains is a leak.
SK.Clear();
SS.Clear();
return 0;
}
