Exemplo n.º 1
0
int SYX_CDECL
main (int argc, char *argv[])
{
  syx_uint64 start, end;
  syx_bool saved, loaded;
  syx_init (0, NULL, "..");

  puts ("- Test saving image");
  start = syx_nanotime ();
  syx_build_basic ();
  saved = syx_memory_save_image ("test.sim");
  assert (saved == TRUE);
  end = syx_nanotime ();
  printf ("Time elapsed: %ld nanoseconds\n\n", end - start);

  puts ("- Test loading image");
  start = syx_nanotime ();
  loaded = syx_memory_load_image ("test.sim");
  assert (loaded == TRUE);
  end = syx_nanotime ();
  printf ("Time elapsed: %ld nanoseconds\n\n", end - start);

  syx_quit ();

  return 0;
}
Exemplo n.º 2
0
int main (int argc, char *argv[])
{
  SyxOop instance;
  SyxOop context;
  SyxOop process;
  SyxOop result;

  /* initialize Syx */
  syx_init (argc, argv, NULL);
  
  /* load the default image */
  syx_memory_load_image (NULL);
  
  /* now file in class and method declarations from our ST file */
  syx_file_in_blocking ("add.st");

  /* create a Sum instance */
  instance = syx_object_new (syx_globals_at ("Sum"));
  
  /* create a Process */
  process = syx_process_new ();

  /* create a MethodContext which sends the #with:and: message */
  context = syx_send_message (instance,                    // the receiver
			      "with:and:",                 // the selector
			      2,                           // the number of arguments
			      syx_small_integer_new (41),   // first argument
			      syx_small_integer_new (22));

  /* enter the context in the created process */
  syx_interp_enter_context (process, context);

  /* execute the process in blocking mode */
  syx_process_execute_blocking (process);

  /* fetch the last returned object (an instance variable of Process) */
  result = SYX_PROCESS_RETURNED_OBJECT (process);

  printf ("The result is %d\n", SYX_SMALL_INTEGER (result));

  /* cleanup Syx */
  syx_quit ();
  
  return 0;
}
Exemplo n.º 3
0
int SYX_CDECL
main (int argc, char *argv[])
{
  SyxLexer *lexer;
  SyxToken token;

  syx_init (0, NULL, "..");

#ifdef HAVE_LIBGMP
  lexer = syx_lexer_new ("nameconst 123 16r123 16rFFFFFFFF 123.321 1e2 1.3e-2 $c $  #symbol #(aaa) \"comment\" 'string' + := -> !!");
#else
  lexer = syx_lexer_new ("nameconst 123 16r123 123.321 1e2 1.3e-2 $c $  #symbol #(aaa) \"comment\" 'string' + := -> !!");
#endif

  token = syx_lexer_next_token (lexer);
  assert (token.type == SYX_TOKEN_NAME_CONST);
  assert (!strcmp (token.value.string, "nameconst"));
  syx_token_free (token);

  token = syx_lexer_next_token (lexer);
  assert (token.type == SYX_TOKEN_INT_CONST);
  assert (token.value.integer == 123);
  syx_token_free (token);

  token = syx_lexer_next_token (lexer);
  assert (token.type == SYX_TOKEN_INT_CONST);
  assert (token.value.integer == 0x123);

#ifdef HAVE_LIBGMP
  token = syx_lexer_next_token (lexer);
  assert (token.type == SYX_TOKEN_LARGE_INT_CONST);
  assert (mpz_cmp_si (*token.value.large_integer, 0xFFFFFFFF) == 0);
#endif

  token = syx_lexer_next_token (lexer);
  assert (token.type == SYX_TOKEN_FLOAT_CONST);
  assert (token.value.floating == 123.321);
  syx_token_free (token);

  token = syx_lexer_next_token (lexer);
  assert (token.type == SYX_TOKEN_FLOAT_CONST);
  assert (token.value.floating == 100.0);
  syx_token_free (token);

  token = syx_lexer_next_token (lexer);
  assert (token.type == SYX_TOKEN_FLOAT_CONST);
  assert (token.value.floating == 0.013);
  syx_token_free (token);

  token = syx_lexer_next_token (lexer);
  assert (token.type == SYX_TOKEN_CHAR_CONST);
  assert (token.value.character == 'c');
  syx_token_free (token);

  token = syx_lexer_next_token (lexer);
  assert (token.type == SYX_TOKEN_CHAR_CONST);
  assert (token.value.character == ' ');
  syx_token_free (token);

  token = syx_lexer_next_token (lexer);
  assert (token.type == SYX_TOKEN_SYM_CONST);
  assert (!strcmp (token.value.string, "symbol"));
  syx_token_free (token);

  token = syx_lexer_next_token (lexer);
  assert (token.type == SYX_TOKEN_ARRAY_BEGIN);
  syx_token_free (token);

  token = syx_lexer_next_token (lexer);
  assert (token.type == SYX_TOKEN_NAME_CONST);
  assert (!strcmp (token.value.string, "aaa"));
  syx_token_free (token);
  
  token = syx_lexer_next_token (lexer);
  assert (token.type == SYX_TOKEN_CLOSING);
  assert (token.value.character == ')');
  syx_token_free (token);

  token = syx_lexer_next_token (lexer);
  assert (token.type == SYX_TOKEN_STR_CONST);
  assert (!strcmp (token.value.string, "string"));
  syx_token_free (token);

  token = syx_lexer_next_token (lexer);
  assert (token.type == SYX_TOKEN_BINARY);
  assert (!strcmp (token.value.string, "+"));
  syx_token_free (token);

  token = syx_lexer_next_token (lexer);
  assert (token.type == SYX_TOKEN_BINARY);
  assert (!strcmp (token.value.string, ":="));
  syx_token_free (token);

  token = syx_lexer_next_token (lexer);
  assert (token.type == SYX_TOKEN_BINARY);
  assert (!strcmp (token.value.string, "->"));
  syx_token_free (token);

  token = syx_lexer_next_token (lexer);
  assert (token.type == SYX_TOKEN_BINARY);
  assert (!strcmp (token.value.string, "!"));
  syx_token_free (token);

  token = syx_lexer_next_token (lexer);
  assert (token.type == SYX_TOKEN_BINARY);
  assert (!strcmp (token.value.string, "!"));
  syx_token_free (token);

  syx_lexer_free (lexer, FALSE);

  return 0;
}
Exemplo n.º 4
0
int SYX_CDECL
main (int argc, char *argv[])
{
  SyxOop process, context;
  SyxOop arguments;
  SyxOop structTestClass;
  SyxOop structTest;

  syx_init (0, NULL, "..");
  syx_memory_load_image ("test.sim");
  syx_scheduler_init ();

  puts ("- Initializing test classes");
  syx_cold_file_in ("stsupport/TestCStruct.st");
  structTestClass = syx_globals_at ("TestCStruct");
  syx_object_initialize (structTestClass);
  structTest = syx_object_new (structTestClass);

  puts ("- Test fields alignment 1");
  arguments = syx_array_new_size (6);
  SYX_OBJECT_DATA(arguments)[0] = syx_small_integer_new ((syx_nint)&test1.f1 - (syx_nint)&test1);
  SYX_OBJECT_DATA(arguments)[1] = syx_small_integer_new ((syx_nint)&test1.f2 - (syx_nint)&test1);
  SYX_OBJECT_DATA(arguments)[2] = syx_small_integer_new ((syx_nint)&test1.f3 - (syx_nint)&test1);
  SYX_OBJECT_DATA(arguments)[3] = syx_small_integer_new ((syx_nint)&test1.f4 - (syx_nint)&test1);
  SYX_OBJECT_DATA(arguments)[4] = syx_small_integer_new ((syx_nint)&test1.f5 - (syx_nint)&test1);
  SYX_OBJECT_DATA(arguments)[5] = syx_small_integer_new ((syx_nint)&test1.f6 - (syx_nint)&test1);
  process = syx_process_new ();
  context = syx_send_message (structTest,
                              "testOffsets:from:",
                              2, arguments, syx_symbol_new ("Test1Struct"));
  syx_interp_enter_context (process, context);
  syx_process_execute_blocking (process);

  puts ("- Test fields alignment 2");
  arguments = syx_array_new_size (14);
  SYX_OBJECT_DATA(arguments)[0] = syx_small_integer_new ((syx_nint)&test2.f1 - (syx_nint)&test2);
  SYX_OBJECT_DATA(arguments)[1] = syx_small_integer_new ((syx_nint)&test2.f2 - (syx_nint)&test2);
  SYX_OBJECT_DATA(arguments)[2] = syx_small_integer_new ((syx_nint)&test2.f3 - (syx_nint)&test2);
  SYX_OBJECT_DATA(arguments)[3] = syx_small_integer_new ((syx_nint)&test2.f4 - (syx_nint)&test2);
  SYX_OBJECT_DATA(arguments)[4] = syx_small_integer_new ((syx_nint)&test2.f5 - (syx_nint)&test2);
  SYX_OBJECT_DATA(arguments)[5] = syx_small_integer_new ((syx_nint)&test2.f6 - (syx_nint)&test2);
  SYX_OBJECT_DATA(arguments)[6] = syx_small_integer_new ((syx_nint)&test2.f7 - (syx_nint)&test2);
  SYX_OBJECT_DATA(arguments)[7] = syx_small_integer_new ((syx_nint)&test2.f8 - (syx_nint)&test2);
  SYX_OBJECT_DATA(arguments)[8] = syx_small_integer_new ((syx_nint)&test2.f9 - (syx_nint)&test2);
  SYX_OBJECT_DATA(arguments)[9] = syx_small_integer_new ((syx_nint)&test2.f10 - (syx_nint)&test2);
  SYX_OBJECT_DATA(arguments)[10] = syx_small_integer_new ((syx_nint)&test2.f11 - (syx_nint)&test2);
  SYX_OBJECT_DATA(arguments)[11] = syx_small_integer_new ((syx_nint)&test2.f12 - (syx_nint)&test2);
  SYX_OBJECT_DATA(arguments)[12] = syx_small_integer_new ((syx_nint)&test2.f13 - (syx_nint)&test2);
  SYX_OBJECT_DATA(arguments)[13] = syx_small_integer_new ((syx_nint)&test2.f14 - (syx_nint)&test2);
  process = syx_process_new ();
  context = syx_send_message (structTest,
                              "testOffsets:from:",
                              2, arguments, syx_symbol_new ("Test2Struct"));
  syx_interp_enter_context (process, context);
  syx_process_execute_blocking (process);

  puts ("- Test fields alignment 3");
  arguments = syx_array_new_size (6);
  SYX_OBJECT_DATA(arguments)[0] = syx_small_integer_new ((syx_nint)&test3.f1 - (syx_nint)&test3);
  SYX_OBJECT_DATA(arguments)[1] = syx_small_integer_new ((syx_nint)&test3.f2 - (syx_nint)&test3);
  SYX_OBJECT_DATA(arguments)[2] = syx_small_integer_new ((syx_nint)&test3.f3 - (syx_nint)&test3);
  SYX_OBJECT_DATA(arguments)[3] = syx_small_integer_new ((syx_nint)&test3.f4 - (syx_nint)&test3);
  SYX_OBJECT_DATA(arguments)[4] = syx_small_integer_new ((syx_nint)&test3.f5 - (syx_nint)&test3);
  SYX_OBJECT_DATA(arguments)[5] = syx_small_integer_new ((syx_nint)&test3.f6 - (syx_nint)&test3);
  process = syx_process_new ();
  context = syx_send_message (structTest,
                              "testOffsets:from:",
                              2, arguments, syx_symbol_new ("Test3Struct"));
  syx_interp_enter_context (process, context);
  syx_process_execute_blocking (process);

  puts ("- Test reading");
  test3.f1 = 240;
  test3.f2 = 7143;
  test3.f3 = 'R';
  test3.f4 = 199.11822;
  test3.f5 = 23.5; /* won't read yet */
  process = syx_process_new ();
  context = syx_send_binary_message (structTest,
                                     "testRead:",
                                     SYX_POINTER_CAST_OOP (&test3));
  syx_interp_enter_context (process, context);
  syx_process_execute_blocking (process);

  puts ("- Test writing");
  process = syx_process_new ();
  context = syx_send_binary_message (structTest,
                                     "testWrite:",
                                     SYX_POINTER_CAST_OOP (&test3));
  syx_interp_enter_context (process, context);
  syx_process_execute_blocking (process);
  assert(test3.f1 == 320);
  assert(test3.f2 == 10293);
  assert(test3.f3 == ',');
  assert(test3.f4 == 291.4837);
  /* Double to float conversion
     assert(test3.f5 == 76.119);
  */
  /* won't write longs yet */

  puts ("- Test unions");
  test4.f1 = 'S';
  process = syx_process_new ();
  context = syx_send_binary_message (structTest,
                                     "testUnion:",
                                     SYX_POINTER_CAST_OOP (&test4));
  syx_interp_enter_context (process, context);
  syx_process_execute_blocking (process);
  assert(test4.f1 == 'T');

  syx_quit ();
  return 0;
}