The translation is temporarily closed for contributions due to maintenance, please come back later.
The translation was automatically locked due to following alerts: Could not merge the repository.
Zen

Translation

English
And now the screen looks like this:
50/350 · 35
English Russian Actions
Now let's call the other function in easy.c -- ``easy2()``. This is almost the same as the ``easy()`` function, but there's a detail: when the file name is not the same as the function name, then we have to specify :samp:`{file-name}.{function-name}`.
Теперь вызовем другую функцию в easy.c -- ``easy2()``. Она практически совпадает с функцией ``easy()``, но есть небольшое отличие: если имя файла не совпадет с именем функции, нужно будет указать :samp:`{имя-файла}.{имя-функции}`.
box.schema.func.create('easy.easy2', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'easy.easy2')
capi_connection:call('easy.easy2')
box.schema.func.create('easy.easy2', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'easy.easy2')
capi_connection:call('easy.easy2')
... and this time the result will be "hello world -- easy2".
... и на этот раз результатом будет: "hello world -- easy2".
Conclusion: calling a C function is easy.
Вывод: вызвать C-функцию легко.
harder.c
**harder.c**
Go back to the shell where the ``easy.c`` program was created.
Вернитесь в терминал, где была создана программа ``easy.c``.
Create a file. Name it ``harder.c``. Put these 17 lines in it:
Создайте файл. Назовите его ``harder.c``. Запишите в него следующие 17 строк:
#include "module.h"
#include "msgpuck.h"
int harder(box_function_ctx_t *ctx, const char *args, const char *args_end)
{
uint32_t arg_count = mp_decode_array(&args);
printf("arg_count = %d\n", arg_count);
uint32_t field_count = mp_decode_array(&args);
printf("field_count = %d\n", field_count);
uint32_t val;
int i;
for (i = 0; i < field_count; ++i)
{
val = mp_decode_uint(&args);
printf("val=%d.\n", val);
}
return 0;
}
#include "module.h"
#include "msgpuck.h"
int harder(box_function_ctx_t *ctx, const char *args, const char *args_end)
{
uint32_t arg_count = mp_decode_array(&args);
printf("arg_count = %d\n", arg_count);
uint32_t field_count = mp_decode_array(&args);
printf("field_count = %d\n", field_count);
uint32_t val;
int i;
for (i = 0; i < field_count; ++i)
{
val = mp_decode_uint(&args);
printf("val=%d.\n", val);
}
return 0;
}
Compile the program, producing a library file named ``harder.so``:
Скомпилируйте программу, что создаст файл библиотеки под названием ``harder.so``:
$ gcc -shared -o harder.so -fPIC harder.c
$ gcc -shared -o harder.so -fPIC harder.c
box.schema.func.create('harder', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'harder')
passable_table = {}
table.insert(passable_table, 1)
table.insert(passable_table, 2)
table.insert(passable_table, 3)
capi_connection:call('harder', {passable_table})
 
This time the call is passing a Lua table (``passable_table``) to the ``harder()`` function. The ``harder()`` function will see it, it's in the :code:`char *args` parameter.
На этот раз вызов передает Lua-таблицу (``passable_table``) в функцию ``harder()``. Функция``harder()`` увидит это, как указано в параметре :code:`char *args`.
At this point the ``harder()`` function will start using functions defined in `msgpuck.h <https://github.com/tarantool/msgpuck>`_. The routines that begin with "mp" are msgpuck functions that handle data formatted according to the `MsgPack <http://msgpack.org/>`_ specification. Passes and returns are always done with this format so one must become acquainted with msgpuck to become proficient with the C API.
 
For now, though, it's enough to know that ``mp_decode_array()`` returns the number of elements in an array, and ``mp_decode_uint`` returns an unsigned integer, from :code:`args`. And there's a side effect: when the decoding finishes, :code:`args` has changed and is now pointing to the next element.
Однако, пока достаточно понимать, что функция ``mp_decode_array()`` возвращает количество элементов в массиве, а функция ``mp_decode_uint`` возвращает целое число без знака из :code:`args`. Есть также побочный эффект: по окончании декодирования :code:`args` изменился и теперь указывает на следующий элемент.
Therefore the first displayed line will be "arg_count = 1" because there was only one item passed: ``passable_table``. |br| The second displayed line will be "field_count = 3" because there are three items in the table. |br| The next three lines will be "1" and "2" and "3" because those are the values in the items in the table.
Таким образом, первой будет отображена строка "arg_count = 1", поскольку был передан только один элемент: ``passable_table``. |br| Второй будет отображена строка "field_count = 3", потому что в таблице находятся три элемента. |br| Следующие три строки будут "1", "2" и "3", потому что это значения элементов в таблице.
And now the screen looks like this:
Теперь вывод на экране выглядит следующим образом:
tarantool> capi_connection:call('harder', passable_table)
arg_count = 1
field_count = 3
val=1.
val=2.
val=3.
---
- []
...
tarantool> capi_connection:call('harder', passable_table)
arg_count = 1
field_count = 3
val=1.
val=2.
val=3.
---
- []
...
Conclusion: decoding parameter values passed to a C function is not easy at first, but there are routines to do the job, and they're documented, and there aren't very many of them.
Вывод: на первый взгляд, декодирование значений параметров, переданных в C-функцию непросто, но существуют документированные процедуры для этих целей, и их не так много.
hardest.c
**hardest.c**
Go back to the shell where the ``easy.c`` and the ``harder.c`` programs were created.
Вернитесь в терминал, где были созданы программы ``easy.c`` и ``harder.c``.
Create a file. Name it ``hardest.c``. Put these 13 lines in it:
Создайте файл. Назовите его ```hardest.c``. Запишите в него следующие 13 строк:
#include "module.h"
#include "msgpuck.h"
int hardest(box_function_ctx_t *ctx, const char *args, const char *args_end)
{
uint32_t space_id = box_space_id_by_name("capi_test", strlen("capi_test"));
char tuple[1024]; /* Must be big enough for mp_encode results */
char *tuple_pointer = tuple;
tuple_pointer = mp_encode_array(tuple_pointer, 2);
tuple_pointer = mp_encode_uint(tuple_pointer, 10000);
tuple_pointer = mp_encode_str(tuple_pointer, "String 2", 8);
int n = box_insert(space_id, tuple, tuple_pointer, NULL);
return n;
}
#include "module.h"
#include "msgpuck.h"
int hardest(box_function_ctx_t *ctx, const char *args, const char *args_end)
{
uint32_t space_id = box_space_id_by_name("capi_test", strlen("capi_test"));
char tuple[1024]; /* Must be big enough for mp_encode results */
char *tuple_pointer = tuple;
tuple_pointer = mp_encode_array(tuple_pointer, 2);
tuple_pointer = mp_encode_uint(tuple_pointer, 10000);
tuple_pointer = mp_encode_str(tuple_pointer, "String 2", 8);
int n = box_insert(space_id, tuple, tuple_pointer, NULL);
return n;
}
Compile the program, producing a library file named ``hardest.so``:
Скомпилируйте программу, что создаст файл библиотеки под названием ``hardest.so``:
$ gcc -shared -o hardest.so -fPIC hardest.c
$ gcc -shared -o hardest.so -fPIC hardest.c
box.schema.func.create('hardest', {language = "C"})
box.schema.user.grant('guest', 'execute', 'function', 'hardest')
box.schema.user.grant('guest', 'read,write', 'space', 'capi_test')
capi_connection:call('hardest')
box.schema.func.create('hardest', {language = "C"})
box.schema.user.grant('guest', 'execute', 'function', 'hardest')
box.schema.user.grant('guest', 'read,write', 'space', 'capi_test')
capi_connection:call('hardest')
This time the C function is doing three things:
На этот раз C-функция выполняет три действия:
finding the numeric identifier of the ``capi_test`` space by calling ``box_space_id_by_name()``;
найдет числовой идентификатор спейса ``capi_test`` путем вызова ``box_space_id_by_name()``;
formatting a tuple using more ``msgpuck.h`` functions;
форматирует кортеж, используя другие функции ``msgpuck.h``;
inserting a tuple using ``box_insert()``.
вставит кортеж с помощью ``box_insert()``.
``char tuple[1024];`` is used here as just a quick way of saying "allocate more than enough bytes". For serious programs the developer must be careful to allow enough space for all the bytes that the ``mp_encode`` routines will use up.
``char tuple[1024];`` используется здесь просто в качестве быстрого способа ввода команды "выделить байтов с запасом". В серьезных программах разработчику следует обратить внимание на то, чтобы выделить достаточно места, которое будут использовать процедуры ``mp_encode``.
Now, still on the client, execute this request:
Затем всё еще в клиенте выполните следующий запрос:

Loading…

User avatar None

String updated in the repository

testing_project / Documentation: how-to/app/c_tutorial — Russian

And now the screen looks like this:
Теперь вывод на экране выглядит следующим образом:
2 years ago
Browse all string changes

Things to check

Reused translation

Other source string: “The screen now looks like this:”

Reset

Glossary

English Russian
No related strings found in the glossary.

String information

String age
2 years ago
Last updated
2 years ago
Source string age
2 years ago
Translation file
locale/ru/LC_MESSAGES/how-to/app/c_tutorial.po, string 60