unsigned long dispatch_gemdos(char * _args)
{
TOSARG(short, callnum);
long rv;
/* Allocate a program structure if needed */
if (prog == NULL)
{
prog = new_program ();
}
/* Check for possible MiNT call */
if (prog->emulate_mint && callnum >= 255)
{
rv = dispatch_mint(_args - 2);
}
else if (callnum < 0 || callnum > arraysize(gemdos_syscalls) ||
!gemdos_syscalls[callnum])
{
DDEBUG( "call to invalid GEMDOS function #%d\n", callnum );
rv = TOS_EINVFN;
}
else
{
STRACE_BEGIN(gemdos, _args);
rv = gemdos_syscalls[ callnum ](_args);
STRACE_END( gemdos, _args, rv );
}
return rv;
}
void rectangle::initialize( platform::context &ctxt )
{
if ( !_stash )
{
if ( ctxt.retrieve_common( this, _stash ) )
{
// new object
//
// Setup program with vertex and fragment shaders
_stash->_mesh.set_program( new_program( ctxt.api(), "simple.vert", "single_color.frag" ) );
// Setup vertices
gl::vertex_buffer_data<gl::vec2> vertices;
vertices.push_back( { 0.F, 0.F } );
vertices.push_back( { 1.F, 0.F } );
vertices.push_back( { 1.F, 1.F } );
vertices.push_back( { 0.F, 1.F } );
vertices.vbo( gl::buffer_usage::STATIC_DRAW );
gl::element_buffer_data elements { 0, 3, 1, 1, 3, 2 };
{
auto bound = _stash->_mesh.bind();
bound.vertex_attribute( "position", vertices );
bound.set_elements( elements );
}
_stash->_mesh.add_triangles( 6 );
_stash->_matrix_loc = _stash->_mesh.get_uniform_location( "matrix" );
_stash->_color_loc = _stash->_mesh.get_uniform_location( "color" );
}
}
}
/*
Use this to create a program.
First, find a program that matches that name. If there's one,
then we put him into edit mode and do it.
Otherwise, we create a new object for him, and call it a program.
*/
void
do_prog(int descr, dbref player, const char *name)
{
dbref i;
struct match_data md;
if (Typeof(player) != TYPE_PLAYER) {
anotify_nolisten2(player, CFAIL "Only players can edit programs.");
return;
} else if (!Mucker(player)) {
anotify_nolisten2(player, CFAIL NOMBIT_MESG);
return;
} else if (!tp_building || tp_db_readonly) {
anotify_nolisten2(player, CFAIL NOBUILD_MESG);
return;
} else if (!*name) {
anotify_nolisten2(player, CINFO "No program name given.");
return;
}
init_match(descr, player, name, TYPE_PROGRAM, &md);
match_possession(&md);
match_neighbor(&md);
match_registered(&md);
match_absolute(&md);
if ((i = match_result(&md)) == NOTHING) {
i = new_program(OWNER(player), name);
FLAGS(i) |= INTERNAL;
DBFETCH(player)->sp.player.curr_prog = i;
anotify_fmt(player, CSUCC "Program %s created with number %d.", name,
i);
anotify_nolisten2(player, CINFO "Entering editor.");
} else if (i == AMBIGUOUS) {
anotify_nolisten2(player, CINFO "I don't know which one you mean!");
return;
} else {
if ((Typeof(i) != TYPE_PROGRAM) || !controls(player, i)) {
anotify_fmt(player, CFAIL "%s", tp_noperm_mesg);
return;
} else if (FLAGS(i) & INTERNAL) {
anotify_nolisten2(player, CFAIL NOEDIT_MESG);
return;
}
DBFETCH(i)->sp.program.first = read_program(i);
FLAGS(i) |= INTERNAL;
DBFETCH(player)->sp.player.curr_prog = i;
anotify_fmt(player, CINFO "Entering editor for %s.",
unparse_object(player, i));
/* list current line */
do_list(player, i, 0, 0, 0);
DBDIRTY(i);
}
FLAGS(player) |= INTERACTIVE;
DBDIRTY(player);
}
a_Program prepend_program( a_Section section, a_Program program, int pos )
{
a_Program a = new_program( section, pos );
a->next = program;
a->linepos = pos;
return a;
}
// Program
error*
create_program_with_source(clobj_t *prog, clobj_t _ctx, const char *_src)
{
auto ctx = static_cast<context*>(_ctx);
return c_handle_error([&] {
const auto &src = _src;
const size_t length = strlen(src);
cl_program result = pyopencl_call_guarded(
clCreateProgramWithSource, ctx, len_arg(src), buf_arg(length));
*prog = new_program(result, KND_SOURCE);
});
}
error*
program__create_with_builtin_kernels(clobj_t *_prg, clobj_t _ctx,
const clobj_t *_devs, uint32_t num_devs,
const char *names)
{
const auto devs = buf_from_class<device>(_devs, num_devs);
auto ctx = static_cast<context*>(_ctx);
return c_handle_error([&] {
auto prg = pyopencl_call_guarded(clCreateProgramWithBuiltInKernels,
ctx, devs, names);
*_prg = new_program(prg);
});
}
error*
program__link(clobj_t *_prg, clobj_t _ctx, const clobj_t *_prgs,
size_t num_prgs, const char *opts, const clobj_t *_devs,
size_t num_devs)
{
const auto devs = buf_from_class<device>(_devs, num_devs);
const auto prgs = buf_from_class<program>(_prgs, num_prgs);
auto ctx = static_cast<context*>(_ctx);
return c_handle_error([&] {
auto prg = pyopencl_call_guarded(clLinkProgram, ctx, devs, opts,
prgs, nullptr, nullptr);
*_prg = new_program(prg);
});
}
error*
create_program_with_binary(clobj_t *prog, clobj_t _ctx,
cl_uint num_devices, const clobj_t *devices,
const unsigned char **binaries, size_t *binary_sizes)
{
auto ctx = static_cast<context*>(_ctx);
const auto devs = buf_from_class<device>(devices, num_devices);
pyopencl_buf<cl_int> binary_statuses(num_devices);
return c_handle_error([&] {
cl_program result = pyopencl_call_guarded(
clCreateProgramWithBinary, ctx, devs,
binary_sizes, binaries, binary_statuses.get());
// for (cl_uint i = 0; i < num_devices; ++i)
// std::cout << i << ":" << binary_statuses[i] << std::endl;
*prog = new_program(result, KND_BINARY);
});
}
int main (int argc, char* argv[])
{
root = (ast_t*) new_program();
if(argc > 1 && !strcmp(argv[1], "-d")) {
//yydebug = 1;
argc--;
argv++;
}
if(argc > 1 && (yyin = fopen(argv[1], "r")) == NULL) {
perror(argv[1]);
exit(1);
}
if(!yyparse()){
printf("Analise sintatica OK!\n");
} else {
printf("ERRO na analise sintatica!\n");
}
s_visit_program ((program_t*) root);
}
int main(int argc, char* argv[])
{
FILE* fp;
int i, j, k;
int cases;
char input[256];
if (argc < 2 || (fp = fopen(argv[1], "rt")) == NULL){
return -1;
}
fgets(input, 256, fp);
sscanf(input, "%d", &cases);
fgets(input, 256, fp);
for (i = 0; i < cases; i++)
{
int num_programs;
simulator_t sim;
memset(&sim, 0, sizeof(sim));
fgets(input, 256, fp);
sscanf(input, "%d %d %d %d %d %d %d",
&num_programs,
&sim.op_cycles[0],
&sim.op_cycles[1],
&sim.op_cycles[2],
&sim.op_cycles[3],
&sim.op_cycles[4],
&sim.time_quantum);
for (j = 0; j < num_programs; j++)
{
sim.ready[j] = sim.programs[j] = new_program(j + 1);
for (k = 0; ; k++)
{
instruction_t* inst;
inst = &sim.programs[j]->code[k];
fgets(input, 256, fp);
if (strncmp(input, "print", 5) == 0)
{
char* var;
inst->type = OP_PRINT;
var = strtok(input + 5, " \t\n");
inst->print.var = var[0] - 'a';
}
else if (strncmp(input, "lock", 4) == 0)
{
inst->type = OP_LOCK;
}
else if (strncmp(input, "unlock", 6) == 0)
{
inst->type = OP_UNLOCK;
}
else if (strncmp(input, "end", 3) == 0)
{
inst->type = OP_END;
}
else
{
char* var;
inst->type = OP_ASSIGNMENT;
var = strtok(input, " \t\n");
inst->assignment.var = var[0] - 'a';
strtok(NULL, " \t\n");
inst->assignment.val = atoi(strtok(NULL, " \t\n"));
}
if (inst->type == OP_END) {
break;
}
}
}
run_simulator(&sim);
}
return EXIT_SUCCESS;
}
TosProgram *load_tos_program( char *filename )
{
TosProgram * prog;
TosExecHeader *hdr;
TosBasepage *bp;
void *prg, *buf;
ulong size;
FILE *fp;
char *env, *src, *dest;
char ascii_num[ 4 ];
/* Allocate a new program structure */
prog = new_program ();
/* Set up the MiNT emulation flag */
DDEBUG( "Environment: %s\n", Opt_environment );
prog->emulate_mint = Opt_MiNT;
/* Set up GEM flag, if program name ends on .app or .prg
and Opt_GEM is not set to "no" */
/* Use case insensitive compare */
if(Opt_GEM && (!strncasecmp(filename+strlen(filename)-4, ".app", 4) ||
!strncasecmp(filename+strlen(filename)-4, ".prg", 4)))
prog->gem = 1;
else
prog->gem = 0;
/* Set up the environment */
if( strcmp( Opt_environment, "-" ) == 0 ) {
env = NULL;
}
else
{
env = (char *)mymalloc( strlen( Opt_environment ) + 2 );
for( src = Opt_environment, dest = env ; *src ; src++ ) {
if( *src == '\\' ) {
src++;
if( *src >= '0' && *src <= '9' ) {
ascii_num[ 0 ] = *src++;
ascii_num[ 1 ] = *src++;
ascii_num[ 2 ] = *src;
ascii_num[ 3 ] = 0;
*dest++ = strtol( ascii_num, NULL, 8 );
}
else {
switch( *src ) {
case 'n':
*dest++ = '\n';
break;
case 'r':
*dest++ = '\r';
break;
default:
*dest++ = *src;
break;
}
}
}
else if( *src == ',' ) {
*dest++ = '\0';
}
else {
*dest++ = *src;
}
}
*dest++ = 0;
*dest++ = 0;
}
/* Set up the trace flag */
prog->trace = Opt_trace;
if( (fp = fopen( filename, "r" )) == NULL ){
fprintf( stderr, "Can't open %s: %s\n", filename, strerror(errno) );
return NULL;
}
/* read the header */
hdr = (TosExecHeader *)mymalloc( sizeof(TosExecHeader) );
if (fread( hdr, sizeof(TosExecHeader), 1, fp ) != 1 ||
ntohs(hdr->magic) != TOS_PROGRAM_MAGIC) {
fprintf( stderr, "%s: no GEMDOS executable\n", filename );
free( hdr );
fclose( fp );
return NULL;
}
/* calculate size of TPA */
size = sizeof(TosBasepage) + ntohl(hdr->tsize) + ntohl(hdr->dsize) +
ntohl(hdr->bsize) + Opt_extra_mem*1024;
buf = (void *)mymalloc( size );
bp = (TosBasepage *)buf;
prg = (void *)(bp + 1);
/* read program text + data */
if(fread(prg, sizeof(char), ntohl(hdr->tsize) + ntohl(hdr->dsize), fp ) !=
ntohl(hdr->tsize) + ntohl(hdr->dsize))
{
fprintf( stderr, "%s: short executable!\n", filename );
err_ret:
free( buf );
free( hdr );
fclose( fp );
return NULL;
}
/* initialize basepage */
bp->lowtpa = htonl((UInt32)bp);
bp->hitpa = htonl((UInt32)buf + size);
bp->tbase = htonl(TEXT_SEGMENT(hdr,prg));
bp->tlen = hdr->tsize;
bp->dbase = htonl(DATA_SEGMENT(hdr,prg));
bp->dlen = hdr->dsize;
bp->bbase = htonl(BSS_SEGMENT(hdr,prg));
bp->blen = hdr->bsize;
bp->parent = (Ptr32)NULL;
bp->env = (char *)htonl((UInt32)env);
bp->cmdlin[ 0 ] = 0;
/* patch_program( hdr ); */
if (relocate_program( bp, hdr, fp ) < 0) {
fprintf( stderr, "%s: relocation failed\n", filename );
goto err_ret;
}
fclose( fp );
/* clear BSS and maybe rest of TPA */
memset((void *)BSS_SEGMENT(hdr,prg), 0,
ntohl(hdr->bsize) +
((ntohl(hdr->prgflags) & TOS_PRGFLAG_FASTLOAD) ? 0 : Opt_extra_mem*1024) );
prog->text = TEXT_SEGMENT(hdr,prg);
prog->data = DATA_SEGMENT(hdr,prg);
prog->bss = BSS_SEGMENT(hdr,prg);
prog->size = size;
prog->basepage = bp;
prog->basepage->dta = (Dta *)ntohl((UInt32)prog->basepage->cmdlin);
prog->dta = (Dta *)ntohl((UInt32)prog->basepage->dta);
/* The program starts in user mode */
prog->super = 0;
/* The program starts in the TOS domain */
prog->domain = 0;
#ifdef DEBUG_STACK
start_stack = BSS_SEGMENT(hdr,prg) + ntohl(hdr->bsize);
#endif
free(hdr);
return prog;
}
