// Set emulator options from command line arguments
static void osint_parse_cmdline (int argc, char *argv[])
{
// Most of this code from Thomas Mathys' vecxsdl
int index;
char *arg;
int have_xres = 0;
int have_yres = 0;
// scan for -h first
index = 0;
while (arg = getnextarg(&index, argc, argv)) {
if ( 0 == strcmp(arg, "-h") ) {
osint_print_usage(stderr);
exit(0);
}
}
// parse other arguments
index = 1;
while (arg = getnextarg(&index, argc, argv)) {
// -b
if ( 0 == strcmp(arg, "-b") ) {
arg = getnextarg(&index, argc, argv);
if (!arg) {
osint_print_usage(stderr);
fprintf(stderr, "\nError : No filename given for -b.\n");
exit(1);
} else {
//args->biosname = arg;
osint_load_bios(arg);
}
}
// -l
else if ( 0 == strcmp(arg, "-l") ) {
arg = getnextarg(&index, argc, argv);
if (!arg) {
osint_print_usage(stderr);
fprintf(stderr, "\nError : No line width given for -l.\n");
exit(1);
} else {
line_width = (float) atof(arg);
if (line_width < 0) {
osint_print_usage(stderr);
fprintf(stderr, "\nError : Line width must be positive.\n");
exit(1);
}
}
}
// -o
else if ( 0 == strcmp(arg, "-o") ) {
arg = getnextarg(&index, argc, argv);
if (!arg) {
osint_print_usage(stderr);
fprintf(stderr, "\nError : no filename given for -o.\n");
exit(1);
} else {
overlayname = arg;
}
}
// -t
else if( 0 == strcmp(arg, "-t") ) {
arg = getnextarg(&index, argc, argv);
if (!arg) {
osint_print_usage(stderr);
fprintf(stderr, "\nError : no transparency given for -t.\n");
exit(1);
} else {
float v = (float) atof(arg);
if ( (v < 0) || (v > 1) ) {
osint_print_usage(stderr);
fprintf(stderr, "\nError : overlay transparency must be in the range [0.0,1.0].\n");
exit(1);
} else {
overlay_transparency = v;
}
}
}
/* // -v
else if ( 0 == strcmp(arg, "-v") ) {
arg = getnextarg(&index, argc, argv);
if (!arg) {
printusage(stderr);
fprintf(stderr, "\nError : no color given for -v.\n");
quit(1);
} else {
unsigned long v;
char *c;
v = strtoul(arg, &c, 16);
if ( (strlen(arg) != 6) || (*c != 0) ) {
printusage(stderr);
fprintf(stderr, "\nError : invalid format for vector color.\n");
quit(1);
} else {
args->vectorcolor[0] = (unsigned char) ((v >> 16) & 255);
args->vectorcolor[1] = (unsigned char) ((v >> 8) & 255);
args->vectorcolor[2] = (unsigned char) (v & 255);
}
}
}
*/ // -x
else if ( 0 == strcmp(arg, "-x") ) {
arg = getnextarg(&index, argc, argv);
if (!arg) {
osint_print_usage(stderr);
fprintf(stderr, "\nError : no window width given for -x.\n");
exit(1);
} else {
screen_x = atoi(arg);
have_xres = 1;
if (screen_x < 0) {
osint_print_usage(stderr);
fprintf(stderr, "\nError : window width must be positive.\n");
exit(1);
}
}
}
// -y
else if ( 0 == strcmp(arg, "-y") ) {
arg = getnextarg(&index, argc, argv);
if (!arg) {
osint_print_usage(stderr);
fprintf(stderr, "\nError : no window height given for -y.\n");
exit(1);
} else {
screen_y = atoi(arg);
have_yres = 1;
if (screen_y < 0) {
osint_print_usage(stderr);
fprintf(stderr, "\nError : window height must be positive.\n");
exit(1);
}
}
}
else {
cartname = arg;
}
}
// if only x or only y given, calculate the other,
// so that the window gets a sane aspect ratio.
if ( (have_xres) && (!have_yres) ) {
screen_y = screen_x*DEFAULT_HEIGHT/DEFAULT_WIDTH;
}
else if ( (!have_xres) && (have_yres) ) {
screen_x = screen_y*DEFAULT_WIDTH/DEFAULT_HEIGHT;
}
// screen width or height may have changed, so need to update scale
osint_updatescale();
}
int main(int argc, char **argv)
{
int infile,outfile,i,rc;
long inBytes,outBytes;
long numFiles;
int memNameLen;
char *memNamePtr;
int opt;
char tempfileName[L_tmpnam];
char linkerString[2000];
char *linkerPath;
char inputFileName[1024]; // input file name
long inLen; // input file len
char *memDataPtr; // pointer to data area
char *fileDataPtr; // pointer to file data
long fileOffset; // current offset to file data
int currentArg = 0;
FILE *inNamefile = NULL;
memFSdata_t *memFSDataPtr; // pointer to memFS data structure
struct stat fileStat;
int fileOpt = 0;
int done = 0;
int verbose = 0;
int currentFiles = 0;
char *listPtr=NULL;
char *outFilePtr = NULL;
char *imageInFilePtr = NULL;
char fileName[] = "cnkmemfs.elf";
mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
if (2 > argc) {
printf("%s requires at least 1 input argument\n",argv[0]);
usage(argv[0]);
exit(-1);
}
opterr = 0;
while ((opt = getopt (argc, argv, "vhf:o:l:")) != -1) {
switch (opt)
{
case 'o':
outFilePtr = optarg;
break;
case 'f':
imageInFilePtr = optarg;
fileOpt = 1;
break;
case 'l':
listPtr = optarg;
break;
case 'v':
verbose = 1;
break;
case 'h':
usage(argv[0]);
return 0;
case '?':
if ((optopt == 'o') || (optopt == 'f') || (optopt == 'l'))
printf ("Option -%c requires an argument.\n", optopt);
else
printf ("invalid option -%c \n", optopt);
usage(argv[0]);
exit(-1);
}
}
// check input parms for sanity
if (NULL != listPtr && 3<argc) {
printf("List option is mutually exclusive with other arguments\n");
usage(argv[0]);
exit(-1);
} else if (NULL != listPtr) {
// do list and out of here
dumpelf(listPtr);
return 0;
}
// check other parms
if (argc > optind && 1 == fileOpt) {
printf("Cannot have both file option and argument list\n");
usage(argv[0]);
exit(-1);
}
if (argc == optind && 0 == fileOpt) {
printf("The file option or an argument list must be specified\n");
usage(argv[0]);
exit(-1);
}
if (0 == fileOpt) {
// input files are command line arguments
numFiles = argc-optind;
if (NUM_FILES < numFiles) {
printf("Too many file arguments\n");
exit(-1);
}
}
// set elf output file name
if (NULL == outFilePtr) outFilePtr = fileName;
// set temp output file name
tmpnam(tempfileName);
// set linker path
linkerPath = getenv("BGQ_LINKERPATH");
if (NULL == linkerPath) {
printf("BGQ_LINKERPATH environment variable not set attempting to use\n%s\n",defaultLinker);
linkerPath=defaultLinker;
}
if (verbose) {
printf("temp file = %s\n",tempfileName);
printf("output file name = %s\n",outFilePtr);
printf("linker path = %s\n",linkerPath);
}
//
// set up memory file system structure
//
if (NULL == (memDataPtr = malloc(MAX_MEMFILE))) { // allocate and point to data area
perror("error allocating work area");
exit(-1);
}
memFSDataPtr = (memFSdata_t*) memDataPtr; // point to memFS data structure
memset(memDataPtr,0x00,sizeof(memFSdata_t)); // clear directory area
fileOffset = sizeof(memFSdata_t); // start of data is after the header
fileDataPtr = memDataPtr + fileOffset;
// set up input type
if (1 == fileOpt) {
// input from file
inNamefile=fopen(imageInFilePtr,"r" );
if (NULL == inNamefile){
perror("open error on member name file");
printf("File in error is %s \n",imageInFilePtr);
exit(-1);
}
} else {
// input from command line
currentArg = optind;
}
//
// copy input files and build directory entries
//
do {
i = currentFiles; // next directory entry slot
if (0 == fileOpt) {
// input from arg list
getnextarg(argv, currentArg, inputFileName, sizeof(inputFileName)-1);
currentFiles++;
currentArg++;
if (currentArg == argc) done = 1;
} else {
// get input from file
rc = getnextentry(inNamefile,inputFileName, sizeof(inputFileName)-1);
if (0 == rc) {
currentFiles++;
if (NUM_FILES < currentFiles) {
printf("Too many input files\n");
exit(-1);
}
} else
break; // last entry already processed
}
// isolate file name
memNamePtr = strrchr(inputFileName,'/'); // find end of path
if (!memNamePtr)
memNamePtr = inputFileName; // name in same dir
else
memNamePtr++; // skip leading /
memNameLen = strlen(memNamePtr);
if (NAME_LEN<memNameLen) {
printf("input file %s file name too long\n",argv[i+1]);
exit(-1);
}
// copy input file to memFS
rc = stat(inputFileName,&fileStat);
if (-1 == rc) {
perror("error on stat");
printf("File in error is %s\n",inputFileName);
exit(-1);
}
inLen = fileStat.st_size;
if (MAX_MEMFILE<(fileOffset + inLen)) {
printf("memFs not large enough for file %s\n",inputFileName);
exit(-1);
}
infile=open(inputFileName,O_RDONLY );
if (-1 == infile){
perror("open error on input");
printf("File in error is %s \n",inputFileName);
exit(-1);
}
inBytes = read(infile,fileDataPtr,inLen);
if (inBytes != inLen){
perror("read error ");
printf("File in error is %s \n",inputFileName);
exit(-1);
}
if (close(infile)) {
printf("FileClose on %s failed\n",inputFileName);
exit(1);
}
// build directory entry for file
memcpy(memFSDataPtr->entry[i].name,memNamePtr,memNameLen);
memFSDataPtr->entry[i].nameLen = htonl(memNameLen);
memFSDataPtr->entry[i].fileOffset = htonl(fileOffset);
memFSDataPtr->entry[i].fileSize = htonl(inLen);
// set up for next file
fileOffset += inLen;
fileDataPtr += inLen;
} while(!done); // end of input file(s) processing
//
// build rest of header for memFS image
//
memcpy(memFSDataPtr->id,MEMFS_ID,8);
memFSDataPtr->totalFSsize = htonl(fileOffset);
memFSDataPtr->totalFSfiles = htonl(currentFiles);
//
// create memFS image file
//
outfile=creat(tempfileName, mode);
if (-1 == outfile){
perror("File create error");
printf("File in error is temp work area %s\n",tempfileName);
exit(-1);
}
outBytes = write(outfile,memDataPtr,fileOffset);
if (outBytes != fileOffset){
perror("Write error ");
printf("File in error is temp work area %s\n",tempfileName);
}
close(outfile);
if (verbose)
dumpdir(memFSDataPtr);
else
printf("Total memFS image size is %ld \n",fileOffset);
free(memDataPtr); // done with in storage version
// call linker to create elf wrapper
sprintf(linkerString,"%s -Tdata=0xc0000000 --entry=0xc0000000 -n -b binary -o %s %s",
linkerPath,outFilePtr,tempfileName);
rc = system(linkerString);
if (0 == rc)
printf("elf image file %s created\n",outFilePtr);
else
printf("elf image file %s create failed\n",outFilePtr);
unlink(tempfileName); // get rid of tempfile
return 0;
}
PyObject *
PyString_Format(PyObject *format, PyObject *args)
{
char *fmt, *res;
int fmtcnt, rescnt, reslen, arglen, argidx;
int args_owned = 0;
PyObject *result, *orig_args;
PyObject *dict = NULL;
if (format == NULL || !PyString_Check(format) || args == NULL) {
/* ERROR */
return NULL;
}
orig_args = args;
fmt = PyString_AS_STRING(format);
fmtcnt = PyString_GET_SIZE(format);
reslen = rescnt = fmtcnt + 100;
result = PyString_FromStringAndSize((char *)NULL, reslen);
if (result == NULL)
return NULL;
res = PyString_AsString(result);
if (PyTuple_Check(args)) {
arglen = PyTuple_GET_SIZE(args);
argidx = 0;
}
else {
arglen = -1;
argidx = -2;
}
if (args->ob_type->tp_as_mapping && !PyTuple_Check(args) &&
!PyObject_TypeCheck(args, &PyBaseString_Type))
dict = args;
while (--fmtcnt >= 0) {
if (*fmt != '%') {
if (--rescnt < 0) {
rescnt = fmtcnt + 100;
reslen += rescnt;
if (_PyString_Resize(&result, reslen) < 0)
return NULL;
res = PyString_AS_STRING(result)
+ reslen - rescnt;
--rescnt;
}
*res++ = *fmt++;
}
else {
/* Got a format specifier */
int flags = 0;
int width = -1;
int prec = -1;
int c = '\0';
int fill;
PyObject *v = NULL;
PyObject *temp = NULL;
char *pbuf;
int sign;
int len;
char formatbuf[FORMATBUFLEN];
/* For format{float,int,char}() */
fmt++;
if (*fmt == '(') {
/* TO DO */
}
while (--fmtcnt >= 0) {
switch (c = *fmt++) {
case '-': flags |= F_LJUST; continue;
case '+': flags |= F_SIGN; continue;
case ' ': flags |= F_BLANK; continue;
case '#': flags |= F_ALT; continue;
case '0': flags |= F_ZERO; continue;
}
break;
}
/* ... */
if (fmtcnt >= 0) {
if (c == 'h' || c == 'l' || c == 'L') {
if (--fmtcnt >= 0)
c = *fmt++;
}
}
if (fmtcnt < 0) {
/* ERROR */
goto error;
}
if (c != '%') {
v = getnextarg(args, arglen, &argidx);
if (v == NULL)
goto error;
}
sign = 0;
fill = ' ';
switch (c) {
case '%':
pbuf = "%";
len = 1;
break;
case 's':
/* Fall through */
case 'r':
if (c == 's')
temp = PyObject_Str(v);
else {
/* TO DO */
goto error;
}
if (temp == NULL)
goto error;
if (!PyString_Check(temp)) {
/* XXX Note: this should never happen,
since PyObject_Repr() and
PyObject_Str() assure this */
/* ERROR */
Py_DECREF(temp);
goto error;
}
pbuf = PyString_AS_STRING(temp);
len = PyString_GET_SIZE(temp);
if (prec >= 0 && len > prec)
len = prec;
break;
case 'i':
case 'd':
case 'u':
case 'o':
case 'x':
case 'X':
pbuf = formatbuf;
/* TO DO */
// len = formatint(pbuf,
// sizeof(formatbuf),
// flags, prec, c, v);
if (len < 0)
goto error;
/* only d conversion is signed */
sign = c == 'd';
if (flags & F_ZERO)
fill = '0';
break;
case 'e':
case 'E':
case 'f':
case 'g':
case 'G':
case 'c':
printf("FORMAT NOT SUPPORTED YET\n");
goto error;
default:
/* ERROR */
goto error;
}
if (sign) {
if (*pbuf == '-' || *pbuf == '+') {
sign = *pbuf++;
len--;
}
else if (flags & F_SIGN)
sign = '+';
else if (flags & F_BLANK)
sign = ' ';
else
sign = 0;
}
if (width < len)
width = len;
if (rescnt - (sign != 0) < width) {
reslen -= rescnt;
rescnt = width + fmtcnt + 100;
reslen += rescnt;
if (reslen < 0) {
Py_DECREF(result);
/* ERROR No mem*/
return NULL;
}
if (_PyString_Resize(&result, reslen) < 0)
return NULL;
res = PyString_AS_STRING(result)
+ reslen - rescnt;
}
if (sign) {
if (fill != ' ')
*res++ = sign;
rescnt--;
if (width > len)
width--;
}
if ((flags & F_ALT) && (c == 'x' || c == 'X')) {
if (fill != ' ') {
*res++ = *pbuf++;
*res++ = *pbuf++;
}
rescnt -= 2;
width -= 2;
if (width < 0)
width = 0;
len -= 2;
}
if (width > len && !(flags & F_LJUST)) {
do {
--rescnt;
*res++ = fill;
} while (--width > len);
}
if (fill == ' ') {
if (sign)
*res++ = sign;
if ((flags & F_ALT) &&
(c == 'x' || c == 'X')) {
*res++ = *pbuf++;
*res++ = *pbuf++;
}
}
memcpy(res, pbuf, len);
res += len;
rescnt -= len;
while (--width >= len) {
--rescnt;
*res++ = ' ';
}
if (dict && (argidx < arglen) && c != '%') {
/* ERROR */
goto error;
}
Py_XDECREF(temp);
} /* '%' */
} /* until end */
if (argidx < arglen && !dict) {
/* ERROR */
goto error;
}
if (args_owned) {
Py_DECREF(args);
}
_PyString_Resize(&result, reslen - rescnt);
return result;
error:
Py_DECREF(result);
if (args_owned) {
Py_DECREF(args);
}
return NULL;
}
PyObject *
Bytes_Format(PyObject *format, PyObject *args)
{
char *fmt, *res;
Py_ssize_t arglen, argidx;
Py_ssize_t reslen, rescnt, fmtcnt;
int args_owned = 0;
PyObject *result;
PyObject *dict = NULL;
if (format == NULL || !Bytes_Check(format) || args == NULL) {
PyErr_BadInternalCall();
return NULL;
}
fmt = Bytes_AS_STRING(format);
fmtcnt = Bytes_GET_SIZE(format);
reslen = rescnt = fmtcnt + 100;
result = Bytes_FromStringAndSize((char *)NULL, reslen);
if (result == NULL)
return NULL;
res = Bytes_AsString(result);
if (PyTuple_Check(args)) {
arglen = PyTuple_GET_SIZE(args);
argidx = 0;
}
else {
arglen = -1;
argidx = -2;
}
if (Py_TYPE(args)->tp_as_mapping && !PyTuple_Check(args) &&
!PyObject_TypeCheck(args, &Bytes_Type))
dict = args;
while (--fmtcnt >= 0) {
if (*fmt != '%') {
if (--rescnt < 0) {
rescnt = fmtcnt + 100;
reslen += rescnt;
if (_Bytes_Resize(&result, reslen))
return NULL;
res = Bytes_AS_STRING(result)
+ reslen - rescnt;
--rescnt;
}
*res++ = *fmt++;
}
else {
/* Got a format specifier */
Py_ssize_t width = -1;
int c = '\0';
PyObject *v = NULL;
PyObject *temp = NULL;
char *pbuf;
Py_ssize_t len;
fmt++;
if (*fmt == '(') {
char *keystart;
Py_ssize_t keylen;
PyObject *key;
int pcount = 1;
if (dict == NULL) {
PyErr_SetString(PyExc_TypeError,
"format requires a mapping");
goto error;
}
++fmt;
--fmtcnt;
keystart = fmt;
/* Skip over balanced parentheses */
while (pcount > 0 && --fmtcnt >= 0) {
if (*fmt == ')')
--pcount;
else if (*fmt == '(')
++pcount;
fmt++;
}
keylen = fmt - keystart - 1;
if (fmtcnt < 0 || pcount > 0) {
PyErr_SetString(PyExc_ValueError,
"incomplete format key");
goto error;
}
key = Text_FromUTF8AndSize(keystart, keylen);
if (key == NULL)
goto error;
if (args_owned) {
Py_DECREF(args);
args_owned = 0;
}
args = PyObject_GetItem(dict, key);
Py_DECREF(key);
if (args == NULL) {
goto error;
}
args_owned = 1;
arglen = -1;
argidx = -2;
}
while (--fmtcnt >= 0) {
c = *fmt++;
break;
}
if (fmtcnt < 0) {
PyErr_SetString(PyExc_ValueError,
"incomplete format");
goto error;
}
if (c != '%') {
v = getnextarg(args, arglen, &argidx);
if (v == NULL)
goto error;
}
switch (c) {
case '%':
pbuf = "%";
len = 1;
break;
case 's':
/* only bytes! */
if (!Bytes_CheckExact(v)) {
PyErr_Format(PyExc_ValueError,
"only bytes values expected, got %s",
Py_TYPE(v)->tp_name);
goto error;
}
temp = v;
Py_INCREF(v);
pbuf = Bytes_AS_STRING(temp);
len = Bytes_GET_SIZE(temp);
break;
default:
PyErr_Format(PyExc_ValueError,
"unsupported format character '%c' (0x%x) "
"at index " FORMAT_CODE_PY_SSIZE_T,
c, c,
(Py_ssize_t)(fmt - 1 -
Bytes_AsString(format)));
goto error;
}
if (width < len)
width = len;
if (rescnt < width) {
reslen -= rescnt;
rescnt = width + fmtcnt + 100;
reslen += rescnt;
if (reslen < 0) {
Py_DECREF(result);
Py_XDECREF(temp);
return PyErr_NoMemory();
}
if (_Bytes_Resize(&result, reslen)) {
Py_XDECREF(temp);
return NULL;
}
res = Bytes_AS_STRING(result)
+ reslen - rescnt;
}
Py_MEMCPY(res, pbuf, len);
res += len;
rescnt -= len;
while (--width >= len) {
--rescnt;
*res++ = ' ';
}
if (dict && (argidx < arglen) && c != '%') {
PyErr_SetString(PyExc_TypeError,
"not all arguments converted during string formatting");
Py_XDECREF(temp);
goto error;
}
Py_XDECREF(temp);
} /* '%' */
} /* until end */
if (argidx < arglen && !dict) {
PyErr_SetString(PyExc_TypeError,
"not all arguments converted during string formatting");
goto error;
}
if (args_owned) {
Py_DECREF(args);
}
if (_Bytes_Resize(&result, reslen - rescnt))
return NULL;
return result;
error:
Py_DECREF(result);
if (args_owned) {
Py_DECREF(args);
}
return NULL;
}
