// 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; }