Beispiel #1
0
int mameql_exec(char *target)
{
    char    filename[FILENAME_MAX+1];
    struct  stat binname_sb;
    FILE   *fpin;
    FILE   *fpout;
    int     i,c;
    
    if ( help )
        return -1;

    if ( binname == NULL ) {
        return -1;
    }

    if ( outfile == NULL ) {
        strcpy(filename,binname);
        suffix_change(filename,".ql");
    } else {
        strcpy(filename,outfile);
    }

    if ( description == NULL ) {
         description = binname;
    }

    if ((origin == -1) && ((crtfile == NULL) || ((origin = get_org_addr(crtfile)) == -1))) {
        origin = 0;
    }
    if ( exec == -1 ) {
        exec = origin;
    }
    
    if ( stat(binname, &binname_sb) < 0 ||
         ( (fpin=fopen_bin(binname, NULL) ) == NULL )) {
        exit_log(1,"Can't open input file %s\n",binname);
    }
    
    if ( ( fpout = fopen(binname, "rb")) == NULL ) {
        exit_log(1,"Can't open input file %s\n", binname);
    }
    
    if ( ( fpout = fopen(filename, "wb")) == NULL ) {
        exit_log(1,"Can't open output file %s\n", filename);
    }

    /* Header */
    writebyte(0xfd, fpout);
    writebyte(0x00, fpout);
    writebyte(0x80, fpout);
    writebyte(0x00, fpout);
    writebyte(0x00, fpout);
    writebyte(0xf9, fpout);
    writebyte(0x01, fpout);	// Varies, what is it?

    /* Write the program name */
    for ( i = 0; i < strlen(description); i++ ) {
        writebyte(description[i], fpout);
    }
    // Description terminator 
    writebyte(0x1a, fpout);
    // Exec address
    writeword(exec, fpout);
    // Start address
    writeword(origin, fpout);
    // End address
    writeword(origin + binname_sb.st_size - 1, fpout);

    for ( i = 0; i < binname_sb.st_size; i++) {
        c = getc(fpin);
        writebyte(c,fpout);
    }    
    fclose(fpin);
    fclose(fpout);
    
    return 0;
}
Beispiel #2
0
int enterprise_exec(char *target)
{
    char    filename[FILENAME_MAX+1];
    FILE   *fpin;
    FILE   *fpout;
    int     len;
    int     c,i;

    if ( help )
        return -1;

    if ( binname == NULL ) {
        return -1;
    }

    if ( outfile == NULL ) {
        strcpy(filename,binname);
        suffix_change(filename, extfile);
    } else {
        strcpy(filename,outfile);
    }

	if ( (fpin=fopen_bin(binname, NULL) ) == NULL ) {
        fprintf(stderr,"Can't open input file %s\n",binname);
        myexit(NULL,1);
    }

 

    if (fseek(fpin,0,SEEK_END)) {
        fprintf(stderr,"Couldn't determine size of file\n");
        fclose(fpin);
        myexit(NULL,1);
    }

    len=ftell(fpin);

    fseek(fpin,0L,SEEK_SET);

    if ( (fpout=fopen(filename,"wb") ) == NULL ) {
        fclose(fpin);
        myexit("Can't open output file\n",1);
    }

    writebyte(0,fpout);
    writebyte(5,fpout);
    writeword(len,fpout);
	for	(i=1;i<=12;i++)
		writebyte(0,fpout);

    for ( i = 0; i < len; i++) {
        c = getc(fpin);
        writebyte(c,fpout);
    }


    fclose(fpin);
    fclose(fpout);

    return 0;
}
Beispiel #3
0
Datei: msx.c Projekt: z88dk/z88dk
int msx_exec(char* target)
{
    char filename[FILENAME_MAX + 1];
    char wavfile[FILENAME_MAX + 1];
    FILE *fpin, *fpout;
    char name[11];
    int c;
    int i;
    int pos;
    int len;

    if (help)
        return -1;

    if (binname == NULL || (!dumb && (crtfile == NULL && origin == -1))) {
        return -1;
    }

    if (origin != -1) {
        pos = origin;
    } else {
        if ((pos = get_org_addr(crtfile)) == -1) {
            myexit("Could not find parameter ZORG (not z88dk compiled?)\n", 1);
        }
    }

    if (loud) {
        msx_h_lvl = 0xFd;
        msx_l_lvl = 2;
    } else {
        msx_h_lvl = 0xe0;
        msx_l_lvl = 0x20;
    }

    if (dumb) {
        strcpy(filename, binname);
    } else {

        if (outfile == NULL) {
            strcpy(filename, binname);
            if (fmsx)
                suffix_change(filename, ".cas");
            else
                suffix_change(filename, ".msx");
        } else {
            strcpy(filename, outfile);
        }

        if ((fpin = fopen_bin(binname, crtfile)) == NULL) {
            printf("Can't open input file %s\n", binname);
            exit(1);
        }

        /*
	 *        Now we try to determine the size of the file
	 *        to be converted
	 */
        if (fseek(fpin, 0, SEEK_END)) {
            printf("Couldn't determine size of file\n");
            fclose(fpin);
            exit(1);
        }

        len = ftell(fpin);

        fseek(fpin, 0L, SEEK_SET);

        if ((fpout = fopen(filename, "wb")) == NULL) {
            printf("Can't open output file\n");
            exit(1);
        }

        /* Write out the header file */

        if (fmsx) {

            /* Block identifier in a CAS file */
            for (i = 0; i < 8; i++)
                fputc(blockid[i], fpout);

            for (i = 0; i < 10; i++)
                fputc(0xd0, fpout);

            /* Deal with the filename */
            if (strlen(binname) >= 6) {
                strncpy(name, binname, 6);
            } else {
                strcpy(name, binname);
                strncat(name, "      ", 6 - strlen(binname));
            }
            for (i = 0; i < 6; i++)
                writebyte(name[i], fpout);

            /* Block identifier in a CAS file */
            for (i = 0; i < 8; i++)
                fputc(blockid[i], fpout);

        } else
            fputc(254, fpout);

        writeword(pos, fpout); /* Start Address */
        writeword(pos + len + 1, fpout); /* End Address */
        writeword(pos, fpout); /* Call Address */

        /* We append the binary file */

        for (i = 0; i < len; i++) {
            c = getc(fpin);
            writebyte(c, fpout);
        }

        if (fmsx) {
            writeword(0, fpout);
        }

        fclose(fpin);
        fclose(fpout);
    }

    if ( disk ) {
        return fat_write_file_to_image("msxbasic", "raw", NULL, filename, NULL, NULL);
    }

    /* ***************************************** */
    /*  Now, if requested, create the audio file */
    /* ***************************************** */
    if ((audio) || (fast) || (loud)) {
        if ((fpin = fopen(filename, "rb")) == NULL) {
            fprintf(stderr, "Can't open file %s for wave conversion\n", filename);
            myexit(NULL, 1);
        }

        if (fseek(fpin, 0, SEEK_END)) {
            fclose(fpin);
            myexit("Couldn't determine size of file\n", 1);
        }
        len = ftell(fpin);
        fseek(fpin, 0, SEEK_SET);

        strcpy(wavfile, filename);

        suffix_change(wavfile, ".RAW");

        if ((fpout = fopen(wavfile, "wb")) == NULL) {
            fprintf(stderr, "Can't open output raw audio file %s\n", wavfile);
            myexit(NULL, 1);
        }

        /* leading silence and tone*/
        for (i = 0; i < 0x3000; i++)
            fputc(0x80, fpout);
        for (i = 0; (i < 8000); i++)
            msx_bit(fpout, 1);

        /* Skip the block id bytes  */
        if (fmsx) {
            for (i = 0; (i < 8); i++)
                c = getc(fpin);
            len -= 8;

            /* Copy the header */
            if (dumb)
                printf("\nInfo: Program Name found in header: ");
            for (i = 0; (i < 16); i++) {
                c = getc(fpin);
                if (dumb && i > 10 && i < 17)
                    printf("%c", c);
                msx_rawout(fpout, c);
            }

            len -= 16;
        }

        /* leading silence and tone*/
        for (i = 0; i < 0x8000; i++)
            fputc(0, fpout);
        for (i = 0; (i < 2000); i++)
            msx_bit(fpout, 1);

        /* Skip the block id bytes  */
        if (fmsx) {
            for (i = 0; (i < 8); i++)
                c = getc(fpin);
            len -= 8;
        }

        /* program block */
        if (len > 0) {
            for (i = 0; i < len; i++) {
                c = getc(fpin);
                msx_rawout(fpout, c);
            }
        }

        fclose(fpin);
        fclose(fpout);

        /* Now complete with the WAV header */
        raw2wav(wavfile);

    } /* END of WAV CONVERSION BLOCK */

    return 0;
}
//this reads in the funky grid, ignoring the material properties at the 
//end of the file, those are now read from frict.data in Read_data()
void Read_grid(int myid, int numprocs, HashTable** NodeTable, ElementsHashTable** ElemTable, MatProps* matprops_ptr,
               OutLine* outline_ptr)
{
    int Node_Num, Elem_Num;
    
    int NODE_TABLE_SIZE = 400000;
    
    //char  filename[14] = "lsh4800xx.inp";
    char filename[14] = "funkyxxxx.inp";
    //unsigned min_key[KEYLENGTH];
    //unsigned max_key[KEYLENGTH];
    double doublekeyrange[2];
    double XRange[2];
    double YRange[2];
    unsigned key[KEYLENGTH];
    double coord[DIMENSION];
    double height;
    Node* NodeP;
    int i, j, k;
    
    // read in nodal data
    sprintf(filename, "funky%04d.inp", myid);
    FILE* fp;
    
    fp = fopen_bin(filename, "r");
    if(!fp)
    {
        printf("Can't open file for %d \n", myid);
        exit(0);
    }
    
    int version, DoublesFromFloats;
    freadI(fp, &version);
    
    switch (version)
    {
        case 20061109:
            DoublesFromFloats = 1;
            break;
        case 20061110:
            DoublesFromFloats = 0;
            break;
        default:
            printf("Read_data() does not recognize binary funkyxxxx.inp version %d\n", version);
            exit(1);
            break;
    }
    
    freadI(fp, &Node_Num);
    
    if(DoublesFromFloats)
    {
        for(i = 0; i < KEYLENGTH; i++)
            freadF2D(fp, &(doublekeyrange[i]));
        
        freadF2D(fp, &(XRange[0]));  //min x
        freadF2D(fp, &(XRange[1]));  //max x
        freadF2D(fp, &(YRange[0]));  //min y
        freadF2D(fp, &(YRange[1]));
    } //max y
    else
    {
        for(i = 0; i < KEYLENGTH; i++)
            freadD(fp, &(doublekeyrange[i]));
        
        freadD(fp, &(XRange[0]));  //min x
        freadD(fp, &(XRange[1]));  //max x
        freadD(fp, &(YRange[0]));  //min y
        freadD(fp, &(YRange[1]));
    } //max y
    
    double xminmax[2], yminmax[2];
    for(i = 0; i < 2; i++)
    {
        XRange[i] = XRange[i] / matprops_ptr->LENGTH_SCALE;
        xminmax[i] = XRange[i];
    }
    for(i = 0; i < 2; i++)
    {
        YRange[i] = YRange[i] / matprops_ptr->LENGTH_SCALE;
        yminmax[i] = YRange[i];
    }
    
    *NodeTable = new HashTable(doublekeyrange, NODE_TABLE_SIZE, XRange, YRange);
    
    for(i = 0; i < Node_Num; i++)
    {
        for(j = 0; j < KEYLENGTH; j++)
            freadU(fp, &(key[j]));
        
        if(DoublesFromFloats)
            for(j = 0; j < DIMENSION; j++)
                freadF2D(fp, &(coord[j]));
        else
            for(j = 0; j < DIMENSION; j++)
                freadD(fp, &(coord[j]));
        
        for(j = 0; j < 2; j++)
            coord[j] = coord[j] / matprops_ptr->LENGTH_SCALE;
        NodeP = new Node(key, coord, matprops_ptr);
        (*NodeTable)->add(key, NodeP);
    }
    (*NodeTable)->print0();
    //done reading in node data
    //start reading in element data
    
    int EL_TABLE_SIZE = 100000;
    
    //char  filename[14] = "lsh4800xx.inp";
    int material, elm_loc[2];
    unsigned opposite_brother[2];
    
    Element* Quad9P;
    float* value = new float[2];
    BC* baddress[4];
    void* p;
    int* assocp;/*--*/
    unsigned* keyP;
    
    unsigned nodes[9][2];
    unsigned neigh[4][2];
    int neighbor_proc[4];
    
    int temp2;
    int interflag;
    
    freadI(fp, &Elem_Num);  //--number of the elements assigned to the proc
           
    *ElemTable = new ElementsHashTable(doublekeyrange, EL_TABLE_SIZE, XRange, YRange, *NodeTable);
    for(int ielem = 0; ielem < Elem_Num; ielem++)
    {
        
        for(j = 0; j < 9; j++)
            for(k = 0; k < KEYLENGTH; k++)
                freadU(fp, &(nodes[j][k]));
        
        interflag = 0;  //---switch for interface
        for(j = 0; j < 4; j++)
        {
            
            freadI(fp, &(neighbor_proc[j]));  //--read the neighbor info
                   
            if(neighbor_proc[j] != -1)  //--if there is neighbor(-1 means the edge is bound)
            {
                if(neighbor_proc[j] != myid) //--the neighbor belongs to other proc
                    interflag = 1; //--switch is used for avoiding nominating neighbor twice
                            
                for(k = 0; k < KEYLENGTH; k++)
                    freadU(fp, &(neigh[j][k])); //--read the left parts of the key
            }
            
            else
                //--there is no neighbor 
                for(k = 0; k < KEYLENGTH; k++)
                    neigh[j][k] = 0;
        }
        
        BC* bcptr = 0;
        int bcf = 0;
        
        //.....the essential boundary conditions....
        
        for(j = 0; j < 4; j++)
        {
            freadI(fp, &temp2);
            
            if(temp2 != -1) //--there is bound constraint
            {
                if(!bcf)
                    bcptr = new BC();
                bcptr->type[j] = 1; //--intialize type
                        
                /* "value" is a FLOAT so DON'T use freadD when DoublesFromFloats
                 is false (and obviously don't use freadD when it's true 
                 either) */
                for(k = 0; k < 2; k++)
                    freadF(fp, &(bcptr->value[j][0][k])); //--j: edge number
                           
                bcf = 1;
            }
        }
        
        //.....the natural boundary conditions.....
        for(j = 0; j < 4; j++)
        {
            
            freadI(fp, &temp2);
            
            if(temp2 != -1) //--there is bound constraint
            {
                if(!bcf)
                    bcptr = new BC();
                if(bcptr->type[j] == 0)
                    bcptr->type[j] = 2; //--intialize type
                else
                    bcptr->type[j] = 3; //--intialize type
                            
                /* "value" is a FLOAT so DON'T use freadD when DoublesFromFloats
                 is false (and obviously don't use freadD when it's true 
                 either) */
                for(k = 0; k < 2; k++)
                    freadF(fp, &(bcptr->value[j][1][k])); //--j: edge number
                           
                bcf = 1;
            }
        }
        
        freadI(fp, &(elm_loc[0]));
        freadI(fp, &(elm_loc[1]));
        freadU(fp, &(opposite_brother[0]));
        freadU(fp, &(opposite_brother[1]));
        freadI(fp, &material);
        double pile_height = 0.0;
        
        if(!bcf)
            bcptr = NULL; //--this element is not on the bound
        Quad9P = (*ElemTable)->generateElement(nodes, neigh, neighbor_proc, bcptr, material, elm_loc, pile_height, myid,
                             opposite_brother);
        (*ElemTable)->add(nodes[8], Quad9P);
        Quad9P->find_positive_x_side(*NodeTable);
        Quad9P->calculate_dx(*NodeTable);
    }
    (*ElemTable)->print0();
    /************************************************************/
    /* need to change this so that smallest cell size is chosen */
    /* based on cube root of volume with failsafe for a minimum */
    /* of 2 cells across smallest pile/flux source axis instead */
    /* of basing it on just the smallest pile/flux source axis  */
    /* which is what we're doing now, will need to print out a  */
    /* warning that the calculation may be slow when the        */
    /* failsafe is activated                                    */
    /************************************************************/

    double dx[2] =
    { *(Quad9P->get_dx() + 0), *(Quad9P->get_dx() + 1) };
    double DX = dx[0];
    if(dx[0] < dx[1])
        DX = dx[1];
    
    REFINE_LEVEL = Quad9P->get_gen()
            + ceil(log(DX * (matprops_ptr->number_of_cells_across_axis) / (matprops_ptr->smallest_axis)) / log(2.0));
    
    //(mdj)2007-04-12 if(REFINE_LEVEL<3) REFINE_LEVEL=3;
    if(REFINE_LEVEL < 0)
        REFINE_LEVEL = 0;
    
    //set the nodal type information
    Element *EmTemp;
    Node *NdTemp;
    int inode;
    int num_buck = (*ElemTable)->get_no_of_buckets();
    HashEntryPtr* buck = (*ElemTable)->getbucketptr();
    for(int i = 0; i < num_buck; i++)
        if(*(buck + i))
        {
            
            HashEntryPtr currentPtr = *(buck + i);
            while (currentPtr)
            {
                
                EmTemp = (Element*) (currentPtr->value);
                currentPtr = currentPtr->next;
                assert(EmTemp);
                
                EmTemp->put_myprocess(myid);
                
                NdTemp = (Node*) (*NodeTable)->lookup(EmTemp->pass_key());
                assert(NdTemp);
                NdTemp->putinfo(BUBBLE);
                
                for(inode = 0; inode < 4; inode++)
                {
                    NdTemp = (Node*) (*NodeTable)->lookup(EmTemp->getNode() + inode * KEYLENGTH);
                    assert(NdTemp);
                    NdTemp->putinfo(CORNER);
                }
                
                for(inode = 4; inode < 8; inode++)
                {
                    NdTemp = (Node*) (*NodeTable)->lookup(EmTemp->getNode() + inode * KEYLENGTH);
                    assert(NdTemp);
                    NdTemp->putinfo(SIDE);
                }
            }
        }
    
#ifdef MAX_DEPTH_MAP
    outline_ptr->init(Quad9P->get_dx(), REFINE_LEVEL - Quad9P->get_gen(), xminmax, yminmax);
#endif
    
    delete[] value;
}