Esempio n. 1
0
Clock_bus::Clock_bus(int id, int size, int number_of_displays, int frequency)
{
  if (size < 2 || size > 28 ||
      number_of_displays < -1 || number_of_displays > 10)
    {
      fatal();
    }

  this->id = id;

  if (!start_timestamp_initialized)
   {
     start_timestamp = time(NULL);
     start_timestamp_initialized = true;
   }
  timestamp = start_timestamp;
  ticks = 0;
  this->frequency = frequency;

  mem_size = 1<<size;
  mem = new char[mem_size];
  
  this->number_of_displays = number_of_displays;
  
  wrote = false;

  if (number_of_displays > 0)
   {
     displays_mem = new char[number_of_displays * 16];
     memset (displays_mem, 0, number_of_displays * 16);
   }
  else if (number_of_displays == -1)
   {
     displays_mem = new char[14];
     memset (displays_mem, 0, 14);
   }
  else
   {
     displays_mem = NULL;
   }
   
  if (!file_slurp(ram_file, mem, mem_size)) fatal();

  cons = new bus_cons(this);
}
Esempio n. 2
0
Memory::Memory(int id, int size, int init_ram)
{
  if (size < 2 || size > 28)
    {
      fatal();
    }

  this->id = id;

  mem_size = 1<<size;
  mem = new char[mem_size];
  
  mod_time = -1;

  if (init_ram)
    {
      if (!file_slurp(ram_file, mem, mem_size)) fatal();
    }

  cons = new memory_cons(this);
}
Esempio n. 3
0
static void
execute_smt (void)
{
    Bool
        cont = TRUE;
    EVENT
       *event;
    struct_ggpars_eof
       *ggpars_eof;
    struct_ggpars_ok
       *ggpars_ok;
    struct_ggpars_error
       *ggpars_error;
    SCRIPT_NODE
       *script_root;
    XML_ITEM
       *xml_item;
    MEMTRN
        *memtrn;
    JOBID
        job;
    DESCR
        *xml_descr;

    while (cont)
      {
        while (cont && (myqueue-> cur_events == 0))
            cont = smt_exec_step ();

        if (myqueue-> cur_events)
          {
            event = event_accept (myqueue, NULL);
            coprintf ("Received event: %s", event-> name);

            if (streq (event-> name, GGPARS_EOF))
              {
                get_ggpars_eof (event-> body, & ggpars_eof);
                job = ggpars_eof-> job;
                coprintf ("Finished job: %i File: %s",
                          job,
                          gsl_argv [(long) job]);
                free_ggpars_eof (& ggpars_eof);
                file_close (scriptfiles [(long) job]);
                scriptfiles [(long) job] = NULL;
              }
            else if (streq (event-> name, GGPARS_OK))
              {
                get_ggpars_ok (event-> body, & ggpars_ok);
                job = ggpars_ok-> job;
                coprintf ("From job: %i File: %s Size = %lu",
                          job,
                          gsl_argv [(long) job],
                          ggpars_ok-> size);
                script_root = (SCRIPT_NODE *) ggpars_ok-> parse_root;
                memtrn =  (MEMTRN *) ggpars_ok-> parse_memtrn;
                free_ggpars_ok (& ggpars_ok);

                xml_item = gg_xml (script_root);
                xml_save_file (xml_item, "testpars.tmp");
                xml_descr = file_slurp ("testpars.tmp");
                coprintf ("%s", xml_descr-> data);
                mem_free (xml_descr);
                file_delete ("testpars.tmp");
                xml_free (xml_item);
                gg_free (script_root);
                memt_assert (memtrn);
                mem_rollback (memtrn);

                if (! gg_parse_template (read_script, job, myqueue))
                    cont = TRUE;

              }
            else if (streq (event-> name, GGPARS_ERROR))
              {
                get_ggpars_error (event-> body, & ggpars_error);
                job = ggpars_error-> job;
                coprintf ("From job: %i File: %s",
                          job,
                          gsl_argv [(long) job]);
                coprintf ("%s", ggpars_error-> error_text);

                free_ggpars_error (& ggpars_error);

                if (! gg_parse_template (read_script, job, myqueue))
                    cont = TRUE;
              }
            coprintf ("");

            event_destroy (event);
          }
      }
}