github.com/Interlisp.maiko
1
0
Fork 0
mirror of https://github.com/Interlisp/maiko.git synced 2026-01-18 17:07:24 +00:00
Code Issues Projects Releases Wiki Activity
Interlisp.maiko/src/xrdopt.c
Nick Briggs 3d9f090e70
Cleanup of includes and related changes based on include-what-you-use diagnostics (#436) 
Remove unused #define PERCENT_OF_SCREEN in MyWindow.h
Move structures for dir.c to dirdefs.h where they are used
Resolve S_CHAR vs S_CHARACTER in favor of S_CHARACTER and cleanup #defines
Fix  = vs == bug in FSDEBUG code in dir.c
Eliminate duplicate/unused constant definitions in gcr.c
Declare static internal function bytecmp in mkatom.c
Update many source and include files to include headers for what they use
2022-08-10 11:07:57 -07:00

327 lines
13 KiB
C
Raw Blame History

/* $Id: xrdopt.c,v 1.6 2001/12/26 22:17:07 sybalsky Exp $ (C) Copyright Venue, All Rights Reserved
*/
/************************************************************************/
/* */
/* (C) Copyright 1989, 1990, 1990, 1991, 1992, 1993, 1994, 1995 Venue. */
/* All Rights Reserved. */
/* Manufactured in the United States of America. */
/* */
/************************************************************************/
#include "version.h"
#include <X11/Xlib.h> // for XPointer, True, XParseGeometry, XResource...
#include <X11/Xresource.h> // for XrmoptionSepArg, XrmGetResource, Xrmoptio...
#include <errno.h> // for errno
#include <limits.h> // for PATH_MAX
#include <stdio.h> // for fprintf, NULL, stderr, sscanf
#include <stdlib.h> // for getenv, exit, strtol
#include <string.h> // for strncpy, strcat, strcpy, strcmp
#include <sys/types.h> // for u_char
#include <unistd.h> // for access, R_OK
#include "version.h" // for MAIKO_ENABLE_ETHERNET
#include "xdefs.h" // for WINDOW_NAME
#include "xrdoptdefs.h" // for print_Xusage, read_Xoption
#ifdef MAIKO_ENABLE_ETHERNET
#if defined(USE_NIT)
#include <net/nit.h> /* needed for Ethernet stuff below */
#endif /* USE_NIT */
#endif /* MAIKO_ENABLE_ETHERNET */
extern int LispWindowRequestedX, LispWindowRequestedY;
extern unsigned LispWindowRequestedWidth, LispWindowRequestedHeight;
extern int LispDisplayRequestedX, LispDisplayRequestedY;
extern unsigned LispDisplayRequestedWidth, LispDisplayRequestedHeight;
extern int xsync;
static XrmOptionDescRec opTable[] = {
{"-help", "*help", XrmoptionIsArg, (XPointer)NULL},
{"-h", "*help", XrmoptionIsArg, (XPointer)NULL},
{"-sysout", "*sysout", XrmoptionSepArg, (XPointer)NULL},
{"-display", "*display", XrmoptionSepArg, (XPointer)NULL},
{"-d", "*display", XrmoptionSepArg, (XPointer)NULL},
{"-borderWidth", "*borderWidth", XrmoptionSepArg, (XPointer)NULL},
{"-bw", "*borderWidth", XrmoptionSepArg, (XPointer)NULL},
{"-screen", "*screen", XrmoptionSepArg, (XPointer)NULL},
{"-sc", "*screen", XrmoptionSepArg, (XPointer)NULL},
{"-geometry", "*geometry", XrmoptionSepArg, (XPointer)NULL},
{"-g", "*geometry", XrmoptionSepArg, (XPointer)NULL},
{"-foreground", "*foreground", XrmoptionSepArg, (XPointer)NULL},
{"-fg", "*foreground", XrmoptionSepArg, (XPointer)NULL},
{"-background", "*background", XrmoptionSepArg, (XPointer)NULL},
{"-bg", "*background", XrmoptionSepArg, (XPointer)NULL},
{"-title", "*title", XrmoptionSepArg, (XPointer)NULL},
{"-t", "*title", XrmoptionSepArg, (XPointer)NULL},
{"-icontitle", "*icontitle", XrmoptionSepArg, (XPointer)NULL},
{"-it", "*icontitle", XrmoptionSepArg, (XPointer)NULL},
{"-iconbitmap", "*iconbitmap", XrmoptionSepArg, (XPointer)NULL},
{"-ibm", "*iconbitmap", XrmoptionSepArg, (XPointer)NULL},
{"-timer", "*timer", XrmoptionSepArg, (XPointer)NULL},
{"-xpages", "*maxpages", XrmoptionSepArg, (XPointer)NULL},
{"-m", "*memory", XrmoptionSepArg, (XPointer)NULL},
{"-NF", "*NoFork", XrmoptionIsArg, (XPointer)NULL},
{"-NoFork", "*NoFork", XrmoptionIsArg, (XPointer)NULL},
{"-noscroll", "*noscroll", XrmoptionIsArg, (XPointer) NULL},
{"-INIT", "*Init", XrmoptionIsArg, (XPointer)NULL},
{"-EtherNet", "*EtherNet", XrmoptionSepArg, (XPointer)NULL},
{"-E", "*EtherNet", XrmoptionSepArg, (XPointer)NULL},
{"-autorepeat", "*autorepeat", XrmoptionSepArg, (XPointer)NULL},
{"-xsync", "*xsync", XrmoptionIsArg, (XPointer)NULL},
};
/* autorepeat is a global setting for X, not anything that
Medley has to be concerned with. Item kept for historical
reasons /jarl
*/
char Display_Name[128];
char iconpixmapfile[1024];
char Window_Title[255];
char Icon_Title[255];
extern char sysout_name[];
extern int sysout_size, for_makeinit, please_fork, noscroll;
/* diagnostic flag for sysout dumping */
/* extern int maxpages; */
/*** Ethernet stuff (JRB) **/
#ifdef MAIKO_ENABLE_ETHERNET
extern int ether_fd;
extern u_char ether_host[6];
#if defined(USE_NIT)
extern struct sockaddr_nit snit;
#endif /* USE_NIT */
#endif /* MAIKO_ENABLE_ETHERNET */
/************************************************************************/
/* */
/* p r i n t _ X u s a g e */
/* */
/* Print out command-line options for X, to help user. */
/* */
/************************************************************************/
void print_Xusage(const char *prog)
{
fprintf(stderr, " %s options:\n", prog);
fprintf(stderr, " [-sysout] [<sysout>] -path to the Medley image\n");
fprintf(stderr, " -h[elp] -prints this text\n");
fprintf(stderr, " -info -prints configuration info\n");
fprintf(stderr, " -d[isplay] <host>:<display>.<screen>\n");
fprintf(stderr,
" -g[eometry] <geom> -size & placement for the medley window on your X "
"screen\n");
fprintf(stderr,
" -sc[reen] <geom> -size & placement for the medley display\n");
fprintf(stderr, " -t[itle] <string> -titlebar text for the window manager\n");
fprintf(stderr, " -icontitle <string> | -it <string> -text for the medley icon\n");
fprintf(stderr, " -iconbitmap <path> | -ibm <path> -bitmap for the medley icon\n");
fprintf(stderr,
" -xsync -turn XSynchronize on. (default is off)\n\n");
fprintf(stderr, "Please refer to the manual for further information.\n\n");
exit(0);
} /* end print_Xusage() */
/************************************************************************/
/* */
/* r e a d _ X o p t i o n */
/* */
/* Parse command-line options related to X windows. */
/* */
/************************************************************************/
void read_Xoption(int *argc, char *argv[])
{
int bitmask;
XrmDatabase commandlineDB = NULL, applicationDB, serverDB, rDB = NULL;
XrmValue value;
char *str_type[30], tmp[1024], *envname;
Display *xdisplay;
int i;
/**********************************************/
/* */
/* Take care of -help flag, which */
/* isn't handled correctly by the X code. */
/* */
/**********************************************/
for (i = 1; i < *argc; i++) {
if (argv[i] && ((strcmp(argv[i], "-help") == 0) || (strcmp(argv[i], "-HELP") == 0))) {
print_Xusage(argv[0]);
exit(0);
}
}
/* Now let X handle the parsing. */
(void)XrmInitialize();
/* If the first argv lacks '-' in front it is the sysout. */
#ifdef NEVEFR
/* JDS 12/20/01: app name should always be "ldex", not what's in argv?? */
XrmParseCommand(&commandlineDB, opTable, opTableEntries, argv[0], argc, argv);
#endif
XrmParseCommand(&commandlineDB, opTable, sizeof(opTable) / sizeof(opTable[0]), "ldex", argc, argv);
if (XrmGetResource(commandlineDB, "ldex.help", "Ldex.Help", str_type, &value) == True) {
print_Xusage(argv[0]);
}
sysout_name[0] = '\0';
if (*argc == 2) { /* There was probably a sysoutarg */
(void)strncpy(sysout_name, argv[1], PATH_MAX - 1);
} else if ((envname = getenv("LDESRCESYSOUT")) != NULL) {
strncpy(sysout_name, envname, PATH_MAX - 1);
} else if ((envname = getenv("LDESOURCESYSOUT")) != NULL)
strncpy(sysout_name, envname, PATH_MAX - 1);
else {
envname = getenv("HOME");
(void)strcat(sysout_name, envname);
(void)strcat(sysout_name, "/lisp.virtualmem");
}
if (access(sysout_name, R_OK) != 0) {
sysout_name[0] = '\0';
}
/* In order to access other DB's we have to open the main display now */
/* This is just temporary. We'll need this display struct to open the */
/* main databases for medley. After it is used the display will be */
/* closed and the opening of the other displays will follow the standard */
/* protocol. */
if (XrmGetResource(commandlineDB, "ldex.display", "Ldex.Display", str_type, &value) == True) {
(void)strncpy(Display_Name, value.addr, (int)value.size);
} else if (getenv("DISPLAY") == (char *)NULL) {
fprintf(stderr, "Can't find a display. Either set the shell\n");
fprintf(stderr, "variable DISPLAY to an appropriate display\n");
fprintf(stderr, "or provide a -display argument.\n");
print_Xusage(argv[0]);
} else {
envname = getenv("DISPLAY");
(void)strcpy(Display_Name, envname);
}
if ((xdisplay = XOpenDisplay(Display_Name)) != NULL) {
/* read the other databases */
/* Start with app-defaults/medley */
(void)strcpy(tmp, "/usr/lib/X11/app-defaults/");
(void)strcat(tmp, "medley");
applicationDB = XrmGetFileDatabase(tmp);
if (applicationDB != NULL) { (void)XrmMergeDatabases(applicationDB, &rDB); }
/* Then try the displays defaults */
if (XResourceManagerString(xdisplay) != NULL) {
serverDB = XrmGetStringDatabase(XResourceManagerString(xdisplay));
if (serverDB != NULL) { (void)XrmMergeDatabases(serverDB, &rDB); }
}
XCloseDisplay(xdisplay);
} else {
fprintf(stderr, "Open_Display: cannot connect to display %s.", XDisplayName(Display_Name));
exit(-1);
}
envname = getenv("HOME");
(void)strcat(tmp, envname);
(void)strcat(tmp, "/.Xdefaults");
if (access(tmp, R_OK) != 0) {
serverDB = XrmGetFileDatabase(tmp);
if (serverDB != NULL) { (void)XrmMergeDatabases(serverDB, &rDB); }
}
/* Now for the commandline */
(void)XrmMergeDatabases(commandlineDB, &rDB);
if (XrmGetResource(rDB, "ldex.sysout", "Ldex.Sysout", str_type, &value) == True) {
/* Get Sysout */
(void)strncpy(sysout_name, value.addr, (int)value.size);
}
if (sysout_name[0] == '\0') {
fprintf(stderr, "Couldn't find a sysout to run;\n");
print_Xusage(argv[0]);
}
if (XrmGetResource(rDB, "ldex.title", "Ldex.Title", str_type, &value) == True) {
(void)strncpy(Window_Title, value.addr, (int)value.size);
} else {
(void)strcpy(Window_Title, WINDOW_NAME);
}
if (XrmGetResource(rDB, "ldex.icontitle", "Ldex.icontitle", str_type, &value) == True) {
(void)strncpy(Icon_Title, value.addr, (int)value.size);
} else {
(void)strcpy(Icon_Title, "Medley");
}
if (XrmGetResource(rDB, "ldex.iconbitmap", "Ldex.Iconbitmap", str_type, &value) == True) {
(void)strncpy(iconpixmapfile, value.addr, (int)value.size);
}
/* Old style geometry definition. */
if (XrmGetResource(rDB, "ldex.geometry", "Ldex.geometry", str_type, &value) == True) {
/* Get Geometry */
(void)strncpy(tmp, value.addr, (int)value.size);
bitmask = XParseGeometry(tmp, &LispWindowRequestedX, &LispWindowRequestedY,
&LispWindowRequestedWidth, &LispWindowRequestedHeight);
}
if (XrmGetResource(rDB, "ldex.screen", "Ldex.screen", str_type, &value) == True) {
/* Get Geometry */
(void)strncpy(tmp, value.addr, (int)value.size);
bitmask = XParseGeometry(tmp, &LispDisplayRequestedX, &LispDisplayRequestedY,
&LispDisplayRequestedWidth, &LispDisplayRequestedHeight);
}
(void)strcpy(tmp, ""); /* Clear the string */
if (XrmGetResource(rDB, "ldex.NoFork", "Ldex.NoFork", str_type, &value) == True) {
please_fork = 0;
}
if (XrmGetResource(rDB, "ldex.noscroll", "Ldex.noscroll", str_type, &value) == True) {
noscroll = 1;
}
/* if (XrmGetResource(rDB,
"ldex.maxpages",
"Ldex.maxpages",
str_type, &value) == True) {
(void)strncpy(tmp, value.addr, (int)value.size);
maxpages = atoi(tmp);
}
*/
if (XrmGetResource(rDB, "ldex.memory", "Ldex.memory", str_type, &value) == True) {
(void)strncpy(tmp, value.addr, (int)value.size);
errno = 0;
i = (int)strtol(tmp, (char **)NULL, 10);
if (errno == 0 && i > 0)
sysout_size = i;
}
if (XrmGetResource(rDB, "ldex.Init", "Ldex.Init", str_type, &value) == True) { for_makeinit = 1; }
if (XrmGetResource(rDB, "ldex.xsync", "Ldex.xsync", str_type, &value) == True) { xsync = True; }
#ifdef MAIKO_ENABLE_ETHERNET
if (XrmGetResource(rDB, "ldex.EtherNet", "Ldex.EtherNet", str_type, &value) == True) {
int b0, b1, b2, b3, b4, b5;
(void)strncpy(tmp, value.addr, (int)value.size);
#if defined(USE_DLPI)
if (sscanf(tmp, "%d:%x:%x:%x:%x:%x:%x", &ether_fd, &b0, &b1, &b2, &b3, &b4, &b5) == 7)
#elif defined(USE_NIT)
if (sscanf(tmp, "%d:%x:%x:%x:%x:%x:%x:%s", &ether_fd, &b0, &b1, &b2, &b3, &b4, &b5,
snit.snit_ifname) == 8)
#endif /* USE_NIT */
{
ether_host[0] = b0;
ether_host[1] = b1;
ether_host[2] = b2;
ether_host[3] = b3;
ether_host[4] = b4;
ether_host[5] = b5;
} else {
fprintf(stderr, "Missing or bogus -E argument\n");
ether_fd = -1;
exit(1);
}
}
#endif /* MAIKO_ENABLE_ETHERNET */
} /* end readXoption */
Reference in New Issue View Git Blame Copy Permalink