ROS 2 rclcpp + rcl - rolling  rolling-e7363f10
ROS 2 C++ Client Library with ROS Client Library
arguments.c
1 // Copyright 2018 Open Source Robotics Foundation, Inc.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
16 
17 #include "rcl/arguments.h"
18 
19 #include <assert.h>
20 #include <stdbool.h>
21 #include <string.h>
22 
23 #include "./arguments_impl.h"
24 #include "./remap_impl.h"
25 #include "rcl/allocator.h"
26 #include "rcl/error_handling.h"
27 #include "rcl/lexer_lookahead.h"
28 #include "rcl/types.h"
30 #include "rcl/visibility_control.h"
31 #include "rcl_yaml_param_parser/parser.h"
32 #include "rcl_yaml_param_parser/types.h"
33 #include "rcutils/allocator.h"
34 #include "rcutils/error_handling.h"
35 #include "rcutils/logging.h"
36 #include "rcutils/logging_macros.h"
37 #include "rcutils/strdup.h"
38 #include "rcutils/types/rcutils_ret.h"
39 
41 
50 RCL_LOCAL
52 _rcl_parse_remap_rule(
53  const char * arg,
54  rcl_allocator_t allocator,
55  rcl_remap_t * output_rule);
56 
58 
69 _rcl_parse_param_rule(
70  const char * arg,
71  rcl_params_t * params);
72 
75  const rcl_arguments_t * arguments,
76  rcl_allocator_t allocator,
77  char *** parameter_files)
78 {
79  RCL_CHECK_ALLOCATOR_WITH_MSG(&allocator, "invalid allocator", return RCL_RET_INVALID_ARGUMENT);
80  RCL_CHECK_ARGUMENT_FOR_NULL(arguments, RCL_RET_INVALID_ARGUMENT);
81  RCL_CHECK_ARGUMENT_FOR_NULL(arguments->impl, RCL_RET_INVALID_ARGUMENT);
82  RCL_CHECK_ARGUMENT_FOR_NULL(parameter_files, RCL_RET_INVALID_ARGUMENT);
83  *(parameter_files) = allocator.allocate(
84  sizeof(char *) * arguments->impl->num_param_files_args, allocator.state);
85  if (NULL == *parameter_files) {
86  return RCL_RET_BAD_ALLOC;
87  }
88  for (int i = 0; i < arguments->impl->num_param_files_args; ++i) {
89  (*parameter_files)[i] = rcutils_strdup(arguments->impl->parameter_files[i], allocator);
90  if (NULL == (*parameter_files)[i]) {
91  // deallocate allocated memory
92  for (int r = i; r >= 0; --r) {
93  allocator.deallocate((*parameter_files)[r], allocator.state);
94  }
95  allocator.deallocate((*parameter_files), allocator.state);
96  (*parameter_files) = NULL;
97  return RCL_RET_BAD_ALLOC;
98  }
99  }
100  return RCL_RET_OK;
101 }
102 
103 int
105  const rcl_arguments_t * args)
106 {
107  if (NULL == args || NULL == args->impl) {
108  return -1;
109  }
110  return args->impl->num_param_files_args;
111 }
112 
113 rcl_ret_t
115  const rcl_arguments_t * arguments,
116  rcl_params_t ** parameter_overrides)
117 {
118  RCL_CHECK_ARGUMENT_FOR_NULL(arguments, RCL_RET_INVALID_ARGUMENT);
119  RCL_CHECK_ARGUMENT_FOR_NULL(arguments->impl, RCL_RET_INVALID_ARGUMENT);
120  RCL_CHECK_ARGUMENT_FOR_NULL(parameter_overrides, RCL_RET_INVALID_ARGUMENT);
121 
122  if (NULL != *parameter_overrides) {
123  RCL_SET_ERROR_MSG("Output parameter override pointer is not null. May leak memory.");
125  }
126  *parameter_overrides = NULL;
127  if (NULL != arguments->impl->parameter_overrides) {
128  *parameter_overrides = rcl_yaml_node_struct_copy(arguments->impl->parameter_overrides);
129  if (NULL == *parameter_overrides) {
130  return RCL_RET_BAD_ALLOC;
131  }
132  }
133  return RCL_RET_OK;
134 }
135 
136 rcl_ret_t
138  const rcl_arguments_t * arguments,
139  rcl_log_levels_t * log_levels)
140 {
141  RCL_CHECK_ARGUMENT_FOR_NULL(arguments, RCL_RET_INVALID_ARGUMENT);
142  RCL_CHECK_ARGUMENT_FOR_NULL(arguments->impl, RCL_RET_INVALID_ARGUMENT);
143  RCL_CHECK_ARGUMENT_FOR_NULL(log_levels, RCL_RET_INVALID_ARGUMENT);
144  const rcl_allocator_t * allocator = &arguments->impl->allocator;
145  RCL_CHECK_ALLOCATOR_WITH_MSG(allocator, "invalid allocator", return RCL_RET_INVALID_ARGUMENT);
146 
147  return rcl_log_levels_copy(&arguments->impl->log_levels, log_levels);
148 }
149 
151 
159 RCL_LOCAL
160 rcl_ret_t
161 _rcl_parse_log_level(
162  const char * arg,
163  rcl_log_levels_t * log_levels);
164 
166 
174 RCL_LOCAL
175 rcl_ret_t
176 _rcl_parse_external_log_file_name(
177  const char * arg,
178  rcl_allocator_t allocator,
179  char ** log_file_name_prefix);
180 
182 
190 RCL_LOCAL
191 rcl_ret_t
192 _rcl_parse_external_log_config_file(
193  const char * arg,
194  rcl_allocator_t allocator,
195  char ** log_config_file);
196 
198 
208 RCL_LOCAL
209 rcl_ret_t
210 _rcl_parse_param_file(
211  const char * arg,
212  rcl_allocator_t allocator,
213  rcl_params_t * params,
214  char ** param_file);
215 
217 
225 RCL_LOCAL
226 rcl_ret_t
227 _rcl_parse_enclave(
228  const char * arg,
229  rcl_allocator_t allocator,
230  char ** enclave);
231 
232 #define RCL_ENABLE_FLAG_PREFIX "--enable-"
233 #define RCL_DISABLE_FLAG_PREFIX "--disable-"
234 
236 
243 RCL_LOCAL
244 rcl_ret_t
245 _rcl_parse_disabling_flag(
246  const char * arg,
247  const char * key,
248  bool * value);
249 
251 
257 rcl_ret_t
258 _rcl_allocate_initialized_arguments_impl(rcl_arguments_t * args, rcl_allocator_t * allocator);
259 
260 rcl_ret_t
262  int argc,
263  const char * const * argv,
264  rcl_allocator_t allocator,
265  rcl_arguments_t * args_output)
266 {
267  RCL_CHECK_ALLOCATOR_WITH_MSG(&allocator, "invalid allocator", return RCL_RET_INVALID_ARGUMENT);
268  if (argc < 0) {
269  RCL_SET_ERROR_MSG("Argument count cannot be negative");
271  } else if (argc > 0) {
272  RCL_CHECK_ARGUMENT_FOR_NULL(argv, RCL_RET_INVALID_ARGUMENT);
273  }
274  RCL_CHECK_ARGUMENT_FOR_NULL(args_output, RCL_RET_INVALID_ARGUMENT);
275 
276  if (args_output->impl != NULL) {
277  RCL_SET_ERROR_MSG("Parse output is not zero-initialized");
279  }
280 
281  rcl_ret_t ret;
282  rcl_ret_t fail_ret;
283 
284  ret = _rcl_allocate_initialized_arguments_impl(args_output, &allocator);
285  if (RCL_RET_OK != ret) {
286  return ret;
287  }
288  rcl_arguments_impl_t * args_impl = args_output->impl;
289 
290  if (argc == 0) {
291  // there are no arguments to parse
292  return RCL_RET_OK;
293  }
294 
295  // over-allocate arrays to match the number of arguments
296  args_impl->remap_rules = allocator.allocate(sizeof(rcl_remap_t) * argc, allocator.state);
297  if (NULL == args_impl->remap_rules) {
298  ret = RCL_RET_BAD_ALLOC;
299  goto fail;
300  }
301 
302  args_impl->parameter_overrides = rcl_yaml_node_struct_init(allocator);
303  if (NULL == args_impl->parameter_overrides) {
304  ret = RCL_RET_BAD_ALLOC;
305  goto fail;
306  }
307 
308  args_impl->parameter_files = allocator.allocate(sizeof(char *) * argc, allocator.state);
309  if (NULL == args_impl->parameter_files) {
310  ret = RCL_RET_BAD_ALLOC;
311  goto fail;
312  }
313  args_impl->unparsed_ros_args = allocator.allocate(sizeof(int) * argc, allocator.state);
314  if (NULL == args_impl->unparsed_ros_args) {
315  ret = RCL_RET_BAD_ALLOC;
316  goto fail;
317  }
318  args_impl->unparsed_args = allocator.allocate(sizeof(int) * argc, allocator.state);
319  if (NULL == args_impl->unparsed_args) {
320  ret = RCL_RET_BAD_ALLOC;
321  goto fail;
322  }
324  ret = rcl_log_levels_init(&log_levels, &allocator, argc);
325  if (ret != RCL_RET_OK) {
326  goto fail;
327  }
328  args_impl->log_levels = log_levels;
329 
330  bool parsing_ros_args = false;
331  for (int i = 0; i < argc; ++i) {
332  if (parsing_ros_args) {
333  // Ignore ROS specific arguments flags
334  if (strcmp(RCL_ROS_ARGS_FLAG, argv[i]) == 0) {
335  continue;
336  }
337 
338  // Check for ROS specific arguments explicit end token
339  if (strcmp(RCL_ROS_ARGS_EXPLICIT_END_TOKEN, argv[i]) == 0) {
340  parsing_ros_args = false;
341  continue;
342  }
343 
344  // Attempt to parse argument as parameter override flag
345  if (strcmp(RCL_PARAM_FLAG, argv[i]) == 0 || strcmp(RCL_SHORT_PARAM_FLAG, argv[i]) == 0) {
346  if (i + 1 < argc) {
347  // Attempt to parse next argument as parameter override rule
348  if (RCL_RET_OK == _rcl_parse_param_rule(argv[i + 1], args_impl->parameter_overrides)) {
349  RCUTILS_LOG_DEBUG_NAMED(
350  ROS_PACKAGE_NAME, "Got param override rule : %s\n", argv[i + 1]);
351  ++i; // Skip flag here, for loop will skip rule.
352  continue;
353  }
354  rcl_error_string_t prev_error_string = rcl_get_error_string();
355  rcl_reset_error();
356  RCL_SET_ERROR_MSG_WITH_FORMAT_STRING(
357  "Couldn't parse parameter override rule: '%s %s'. Error: %s", argv[i], argv[i + 1],
358  prev_error_string.str);
359  } else {
360  RCL_SET_ERROR_MSG_WITH_FORMAT_STRING(
361  "Couldn't parse trailing %s flag. No parameter override rule found.", argv[i]);
362  }
364  goto fail;
365  }
366  RCUTILS_LOG_DEBUG_NAMED(
367  ROS_PACKAGE_NAME, "Arg %d (%s) is not a %s nor a %s flag.",
368  i, argv[i], RCL_PARAM_FLAG, RCL_SHORT_PARAM_FLAG);
369 
370  // Attempt to parse argument as remap rule flag
371  if (strcmp(RCL_REMAP_FLAG, argv[i]) == 0 || strcmp(RCL_SHORT_REMAP_FLAG, argv[i]) == 0) {
372  if (i + 1 < argc) {
373  // Attempt to parse next argument as remap rule
374  rcl_remap_t * rule = &(args_impl->remap_rules[args_impl->num_remap_rules]);
376  if (RCL_RET_OK == _rcl_parse_remap_rule(argv[i + 1], allocator, rule)) {
377  ++(args_impl->num_remap_rules);
378  RCUTILS_LOG_DEBUG_NAMED(ROS_PACKAGE_NAME, "Got remap rule : %s\n", argv[i + 1]);
379  ++i; // Skip flag here, for loop will skip rule.
380  continue;
381  }
382  rcl_error_string_t prev_error_string = rcl_get_error_string();
383  rcl_reset_error();
384  RCL_SET_ERROR_MSG_WITH_FORMAT_STRING(
385  "Couldn't parse remap rule: '%s %s'. Error: %s", argv[i], argv[i + 1],
386  prev_error_string.str);
387  } else {
388  RCL_SET_ERROR_MSG_WITH_FORMAT_STRING(
389  "Couldn't parse trailing %s flag. No remap rule found.", argv[i]);
390  }
392  goto fail;
393  }
394  RCUTILS_LOG_DEBUG_NAMED(
395  ROS_PACKAGE_NAME, "Arg %d (%s) is not a %s nor a %s flag.",
396  i, argv[i], RCL_REMAP_FLAG, RCL_SHORT_REMAP_FLAG);
397 
398  // Attempt to parse argument as parameter file rule
399  if (strcmp(RCL_PARAM_FILE_FLAG, argv[i]) == 0) {
400  if (i + 1 < argc) {
401  // Attempt to parse next argument as parameter file rule
402  args_impl->parameter_files[args_impl->num_param_files_args] = NULL;
403  if (
404  RCL_RET_OK == _rcl_parse_param_file(
405  argv[i + 1], allocator, args_impl->parameter_overrides,
406  &args_impl->parameter_files[args_impl->num_param_files_args]))
407  {
408  ++(args_impl->num_param_files_args);
409  RCUTILS_LOG_DEBUG_NAMED(
410  ROS_PACKAGE_NAME,
411  "Got params file : %s\ntotal num param files %d",
412  args_impl->parameter_files[args_impl->num_param_files_args - 1],
413  args_impl->num_param_files_args);
414  ++i; // Skip flag here, for loop will skip rule.
415  continue;
416  }
417  rcl_error_string_t prev_error_string = rcl_get_error_string();
418  rcl_reset_error();
419  RCL_SET_ERROR_MSG_WITH_FORMAT_STRING(
420  "Couldn't parse params file: '%s %s'. Error: %s", argv[i], argv[i + 1],
421  prev_error_string.str);
422  } else {
423  RCL_SET_ERROR_MSG_WITH_FORMAT_STRING(
424  "Couldn't parse trailing %s flag. No file path provided.", argv[i]);
425  }
427  goto fail;
428  }
429  RCUTILS_LOG_DEBUG_NAMED(
430  ROS_PACKAGE_NAME, "Arg %d (%s) is not a %s flag.",
431  i, argv[i], RCL_PARAM_FILE_FLAG);
432 
433  // Attempt to parse argument as log level configuration
434  if (strcmp(RCL_LOG_LEVEL_FLAG, argv[i]) == 0) {
435  if (i + 1 < argc) {
436  if (RCL_RET_OK ==
437  _rcl_parse_log_level(argv[i + 1], &args_impl->log_levels))
438  {
439  RCUTILS_LOG_DEBUG_NAMED(ROS_PACKAGE_NAME, "Got log level: %s\n", argv[i + 1]);
440  ++i; // Skip flag here, for loop will skip value.
441  continue;
442  }
443  rcl_error_string_t prev_error_string = rcl_get_error_string();
444  rcl_reset_error();
445  RCL_SET_ERROR_MSG_WITH_FORMAT_STRING(
446  "Couldn't parse log level: '%s %s'. Error: %s", argv[i], argv[i + 1],
447  prev_error_string.str);
448  } else {
449  RCL_SET_ERROR_MSG_WITH_FORMAT_STRING(
450  "Couldn't parse trailing log level flag: '%s'. No log level provided.", argv[i]);
451  }
453  goto fail;
454  }
455  RCUTILS_LOG_DEBUG_NAMED(
456  ROS_PACKAGE_NAME, "Arg %d (%s) is not a %s flag.",
457  i, argv[i], RCL_LOG_LEVEL_FLAG);
458 
459  // Attempt to parse argument as external log file name prefix
460  if (strcmp(RCL_EXTERNAL_LOG_FILE_NAME_PREFIX, argv[i]) == 0) {
461  if (i + 1 < argc) {
462  if (NULL != args_impl->external_log_file_name_prefix) {
463  RCUTILS_LOG_DEBUG_NAMED(
464  ROS_PACKAGE_NAME, "Overriding log file name : %s\n",
465  args_impl->external_log_file_name_prefix);
466  allocator.deallocate(args_impl->external_log_file_name_prefix, allocator.state);
467  args_impl->external_log_file_name_prefix = NULL;
468  }
469  if (RCL_RET_OK == _rcl_parse_external_log_file_name(
470  argv[i + 1], allocator, &args_impl->external_log_file_name_prefix))
471  {
472  RCUTILS_LOG_DEBUG_NAMED(
473  ROS_PACKAGE_NAME, "Got log file name prefix : %s\n",
474  args_impl->external_log_file_name_prefix);
475  ++i; // Skip flag here, for loop will skip value.
476  continue;
477  }
478  rcl_error_string_t prev_error_string = rcl_get_error_string();
479  rcl_reset_error();
480  RCL_SET_ERROR_MSG_WITH_FORMAT_STRING(
481  "Couldn't parse log file name prefix: '%s %s'. Error: %s", argv[i], argv[i + 1],
482  prev_error_string.str);
483  } else {
484  RCL_SET_ERROR_MSG_WITH_FORMAT_STRING(
485  "Couldn't parse trailing %s flag. No string prefix provided.", argv[i]);
486  }
488  goto fail;
489  }
490  RCUTILS_LOG_DEBUG_NAMED(
491  ROS_PACKAGE_NAME, "Arg %d (%s) is not a %s flag.",
493 
494  // Attempt to parse argument as log configuration file
495  if (strcmp(RCL_EXTERNAL_LOG_CONFIG_FLAG, argv[i]) == 0) {
496  if (i + 1 < argc) {
497  if (NULL != args_impl->external_log_config_file) {
498  RCUTILS_LOG_DEBUG_NAMED(
499  ROS_PACKAGE_NAME, "Overriding log configuration file : %s\n",
500  args_impl->external_log_config_file);
501  allocator.deallocate(args_impl->external_log_config_file, allocator.state);
502  args_impl->external_log_config_file = NULL;
503  }
504  if (RCL_RET_OK == _rcl_parse_external_log_config_file(
505  argv[i + 1], allocator, &args_impl->external_log_config_file))
506  {
507  RCUTILS_LOG_DEBUG_NAMED(
508  ROS_PACKAGE_NAME, "Got log configuration file : %s\n",
509  args_impl->external_log_config_file);
510  ++i; // Skip flag here, for loop will skip value.
511  continue;
512  }
513  rcl_error_string_t prev_error_string = rcl_get_error_string();
514  rcl_reset_error();
515  RCL_SET_ERROR_MSG_WITH_FORMAT_STRING(
516  "Couldn't parse log configuration file: '%s %s'. Error: %s", argv[i], argv[i + 1],
517  prev_error_string.str);
518  } else {
519  RCL_SET_ERROR_MSG_WITH_FORMAT_STRING(
520  "Couldn't parse trailing %s flag. No file path provided.", argv[i]);
521  }
523  goto fail;
524  }
525  RCUTILS_LOG_DEBUG_NAMED(
526  ROS_PACKAGE_NAME, "Arg %d (%s) is not a %s flag.",
527  i, argv[i], RCL_EXTERNAL_LOG_CONFIG_FLAG);
528 
529  // Attempt to parse argument as a security enclave
530  if (strcmp(RCL_ENCLAVE_FLAG, argv[i]) == 0 || strcmp(RCL_SHORT_ENCLAVE_FLAG, argv[i]) == 0) {
531  if (i + 1 < argc) {
532  if (NULL != args_impl->enclave) {
533  RCUTILS_LOG_DEBUG_NAMED(
534  ROS_PACKAGE_NAME, "Overriding security enclave : %s\n",
535  args_impl->enclave);
536  allocator.deallocate(args_impl->enclave, allocator.state);
537  args_impl->enclave = NULL;
538  }
539  if (RCL_RET_OK == _rcl_parse_enclave(
540  argv[i + 1], allocator, &args_impl->enclave))
541  {
542  RCUTILS_LOG_DEBUG_NAMED(
543  ROS_PACKAGE_NAME, "Got enclave: %s\n",
544  args_impl->enclave);
545  ++i; // Skip flag here, for loop will skip value.
546  continue;
547  }
548  rcl_error_string_t prev_error_string = rcl_get_error_string();
549  rcl_reset_error();
550  RCL_SET_ERROR_MSG_WITH_FORMAT_STRING(
551  "Couldn't parse enclave name: '%s %s'. Error: %s", argv[i], argv[i + 1],
552  prev_error_string.str);
553  } else {
554  RCL_SET_ERROR_MSG_WITH_FORMAT_STRING(
555  "Couldn't parse trailing %s flag. No enclave path provided.", argv[i]);
556  }
558  goto fail;
559  }
560  RCUTILS_LOG_DEBUG_NAMED(
561  ROS_PACKAGE_NAME, "Arg %d (%s) is not a %s flag.",
562  i, argv[i], RCL_ENCLAVE_FLAG);
563 
564  // Attempt to parse --enable/disable-stdout-logs flag
565  ret = _rcl_parse_disabling_flag(
566  argv[i], RCL_LOG_STDOUT_FLAG_SUFFIX, &args_impl->log_stdout_disabled);
567  if (RCL_RET_OK == ret) {
568  RCUTILS_LOG_DEBUG_NAMED(
569  ROS_PACKAGE_NAME, "Disable log stdout ? %s\n",
570  args_impl->log_stdout_disabled ? "true" : "false");
571  continue;
572  }
573  RCUTILS_LOG_DEBUG_NAMED(
574  ROS_PACKAGE_NAME,
575  "Couldn't parse arg %d (%s) as %s%s or %s%s flag. Error: %s",
576  i, argv[i], RCL_ENABLE_FLAG_PREFIX, RCL_LOG_STDOUT_FLAG_SUFFIX,
577  RCL_DISABLE_FLAG_PREFIX, RCL_LOG_STDOUT_FLAG_SUFFIX, rcl_get_error_string().str);
578  rcl_reset_error();
579 
580  // Attempt to parse --enable/disable-rosout-logs flag
581  ret = _rcl_parse_disabling_flag(
582  argv[i], RCL_LOG_ROSOUT_FLAG_SUFFIX, &args_impl->log_rosout_disabled);
583  if (RCL_RET_OK == ret) {
584  RCUTILS_LOG_DEBUG_NAMED(
585  ROS_PACKAGE_NAME, "Disable log rosout ? %s\n",
586  args_impl->log_rosout_disabled ? "true" : "false");
587  continue;
588  }
589  RCUTILS_LOG_DEBUG_NAMED(
590  ROS_PACKAGE_NAME,
591  "Couldn't parse arg %d (%s) as %s%s or %s%s flag. Error: %s",
592  i, argv[i], RCL_ENABLE_FLAG_PREFIX, RCL_LOG_ROSOUT_FLAG_SUFFIX,
593  RCL_DISABLE_FLAG_PREFIX, RCL_LOG_ROSOUT_FLAG_SUFFIX, rcl_get_error_string().str);
594  rcl_reset_error();
595 
596  // Attempt to parse --enable/disable-external-lib-logs flag
597  ret = _rcl_parse_disabling_flag(
598  argv[i], RCL_LOG_EXT_LIB_FLAG_SUFFIX, &args_impl->log_ext_lib_disabled);
599  if (RCL_RET_OK == ret) {
600  RCUTILS_LOG_DEBUG_NAMED(
601  ROS_PACKAGE_NAME, "Disable log external lib ? %s\n",
602  args_impl->log_ext_lib_disabled ? "true" : "false");
603  continue;
604  }
605  RCUTILS_LOG_DEBUG_NAMED(
606  ROS_PACKAGE_NAME,
607  "Couldn't parse arg %d (%s) as %s%s or %s%s flag. Error: %s",
608  i, argv[i], RCL_ENABLE_FLAG_PREFIX, RCL_LOG_EXT_LIB_FLAG_SUFFIX,
609  RCL_DISABLE_FLAG_PREFIX, RCL_LOG_EXT_LIB_FLAG_SUFFIX, rcl_get_error_string().str);
610  rcl_reset_error();
611 
612  // Argument is an unknown ROS specific argument
613  args_impl->unparsed_ros_args[args_impl->num_unparsed_ros_args] = i;
614  ++(args_impl->num_unparsed_ros_args);
615  } else {
616  // Check for ROS specific arguments flags
617  if (strcmp(RCL_ROS_ARGS_FLAG, argv[i]) == 0) {
618  parsing_ros_args = true;
619  continue;
620  }
621 
622  // Attempt to parse argument as remap rule in its deprecated form
623  rcl_remap_t * rule = &(args_impl->remap_rules[args_impl->num_remap_rules]);
625  if (RCL_RET_OK == _rcl_parse_remap_rule(argv[i], allocator, rule)) {
626  RCUTILS_LOG_WARN_NAMED(
627  ROS_PACKAGE_NAME,
628  "Found remap rule '%s'. This syntax is deprecated. Use '%s %s %s' instead.",
629  argv[i], RCL_ROS_ARGS_FLAG, RCL_REMAP_FLAG, argv[i]);
630  RCUTILS_LOG_DEBUG_NAMED(ROS_PACKAGE_NAME, "Got remap rule : %s\n", argv[i + 1]);
631  ++(args_impl->num_remap_rules);
632  continue;
633  }
634  RCUTILS_LOG_DEBUG_NAMED(
635  ROS_PACKAGE_NAME,
636  "Couldn't parse arg %d (%s) as a remap rule in its deprecated form. Error: %s",
637  i, argv[i], rcl_get_error_string().str);
638  rcl_reset_error();
639 
640  // Argument is not a ROS specific argument
641  args_impl->unparsed_args[args_impl->num_unparsed_args] = i;
642  ++(args_impl->num_unparsed_args);
643  }
644  }
645 
646  // Shrink remap_rules array to match number of successfully parsed rules
647  if (0 == args_impl->num_remap_rules) {
648  // No remap rules
649  allocator.deallocate(args_impl->remap_rules, allocator.state);
650  args_impl->remap_rules = NULL;
651  } else if (args_impl->num_remap_rules < argc) {
652  rcl_remap_t * new_remap_rules = allocator.reallocate(
653  args_impl->remap_rules,
654  sizeof(rcl_remap_t) * args_impl->num_remap_rules,
655  &allocator);
656  if (NULL == new_remap_rules) {
657  ret = RCL_RET_BAD_ALLOC;
658  goto fail;
659  }
660  args_impl->remap_rules = new_remap_rules;
661  }
662 
663  // Shrink Parameter files
664  if (0 == args_impl->num_param_files_args) {
665  allocator.deallocate(args_impl->parameter_files, allocator.state);
666  args_impl->parameter_files = NULL;
667  } else if (args_impl->num_param_files_args < argc) {
668  char ** new_parameter_files = allocator.reallocate(
669  args_impl->parameter_files,
670  sizeof(char *) * args_impl->num_param_files_args,
671  &allocator);
672  if (NULL == new_parameter_files) {
673  ret = RCL_RET_BAD_ALLOC;
674  goto fail;
675  }
676  args_impl->parameter_files = new_parameter_files;
677  }
678 
679  // Drop parameter overrides if none was found.
680  if (0U == args_impl->parameter_overrides->num_nodes) {
681  rcl_yaml_node_struct_fini(args_impl->parameter_overrides);
682  args_impl->parameter_overrides = NULL;
683  }
684 
685  // Shrink unparsed_ros_args
686  if (0 == args_impl->num_unparsed_ros_args) {
687  // No unparsed ros args
688  allocator.deallocate(args_impl->unparsed_ros_args, allocator.state);
689  args_impl->unparsed_ros_args = NULL;
690  } else if (args_impl->num_unparsed_ros_args < argc) {
691  args_impl->unparsed_ros_args = rcutils_reallocf(
692  args_impl->unparsed_ros_args, sizeof(int) * args_impl->num_unparsed_ros_args, &allocator);
693  if (NULL == args_impl->unparsed_ros_args) {
694  ret = RCL_RET_BAD_ALLOC;
695  goto fail;
696  }
697  }
698 
699  // Shrink unparsed_args
700  if (0 == args_impl->num_unparsed_args) {
701  // No unparsed args
702  allocator.deallocate(args_impl->unparsed_args, allocator.state);
703  args_impl->unparsed_args = NULL;
704  } else if (args_impl->num_unparsed_args < argc) {
705  args_impl->unparsed_args = rcutils_reallocf(
706  args_impl->unparsed_args, sizeof(int) * args_impl->num_unparsed_args, &allocator);
707  if (NULL == args_impl->unparsed_args) {
708  ret = RCL_RET_BAD_ALLOC;
709  goto fail;
710  }
711  }
712 
713  // Shrink logger settings of log levels
714  ret = rcl_log_levels_shrink_to_size(&args_impl->log_levels);
715  if (ret != RCL_RET_OK) {
716  goto fail;
717  }
718 
719  return RCL_RET_OK;
720 fail:
721  fail_ret = ret;
722  if (NULL != args_impl) {
723  ret = rcl_arguments_fini(args_output);
724  if (RCL_RET_OK != ret) {
725  RCUTILS_LOG_ERROR_NAMED(ROS_PACKAGE_NAME, "Failed to fini arguments after earlier failure");
726  }
727  }
728  return fail_ret;
729 }
730 
731 int
733  const rcl_arguments_t * args)
734 {
735  if (NULL == args || NULL == args->impl) {
736  return -1;
737  }
738  return args->impl->num_unparsed_args;
739 }
740 
741 rcl_ret_t
743  const rcl_arguments_t * args,
744  rcl_allocator_t allocator,
745  int ** output_unparsed_indices)
746 {
747  RCL_CHECK_ARGUMENT_FOR_NULL(args, RCL_RET_INVALID_ARGUMENT);
748  RCL_CHECK_ARGUMENT_FOR_NULL(args->impl, RCL_RET_INVALID_ARGUMENT);
749  RCL_CHECK_ALLOCATOR_WITH_MSG(&allocator, "invalid allocator", return RCL_RET_INVALID_ARGUMENT);
750  RCL_CHECK_ARGUMENT_FOR_NULL(output_unparsed_indices, RCL_RET_INVALID_ARGUMENT);
751 
752  *output_unparsed_indices = NULL;
753  if (args->impl->num_unparsed_args) {
754  *output_unparsed_indices = allocator.allocate(
755  sizeof(int) * args->impl->num_unparsed_args, allocator.state);
756  if (NULL == *output_unparsed_indices) {
757  return RCL_RET_BAD_ALLOC;
758  }
759  for (int i = 0; i < args->impl->num_unparsed_args; ++i) {
760  (*output_unparsed_indices)[i] = args->impl->unparsed_args[i];
761  }
762  }
763  return RCL_RET_OK;
764 }
765 
766 int
768  const rcl_arguments_t * args)
769 {
770  if (NULL == args || NULL == args->impl) {
771  return -1;
772  }
773  return args->impl->num_unparsed_ros_args;
774 }
775 
776 rcl_ret_t
778  const rcl_arguments_t * args,
779  rcl_allocator_t allocator,
780  int ** output_unparsed_ros_indices)
781 {
782  RCL_CHECK_ARGUMENT_FOR_NULL(args, RCL_RET_INVALID_ARGUMENT);
783  RCL_CHECK_ARGUMENT_FOR_NULL(args->impl, RCL_RET_INVALID_ARGUMENT);
784  RCL_CHECK_ALLOCATOR_WITH_MSG(&allocator, "invalid allocator", return RCL_RET_INVALID_ARGUMENT);
785  RCL_CHECK_ARGUMENT_FOR_NULL(output_unparsed_ros_indices, RCL_RET_INVALID_ARGUMENT);
786 
787  *output_unparsed_ros_indices = NULL;
788  if (args->impl->num_unparsed_ros_args) {
789  *output_unparsed_ros_indices = allocator.allocate(
790  sizeof(int) * args->impl->num_unparsed_ros_args, allocator.state);
791  if (NULL == *output_unparsed_ros_indices) {
792  return RCL_RET_BAD_ALLOC;
793  }
794  for (int i = 0; i < args->impl->num_unparsed_ros_args; ++i) {
795  (*output_unparsed_ros_indices)[i] = args->impl->unparsed_ros_args[i];
796  }
797  }
798  return RCL_RET_OK;
799 }
800 
803 {
804  // All members are initialized to 0 or NULL by C99 6.7.8/10.
805  static rcl_arguments_t zero_arguments;
806  return zero_arguments;
807 }
808 
809 rcl_ret_t
811  const char * const * argv,
812  const rcl_arguments_t * args,
813  rcl_allocator_t allocator,
814  int * nonros_argc,
815  const char *** nonros_argv)
816 {
817  RCL_CHECK_ARGUMENT_FOR_NULL(args, RCL_RET_INVALID_ARGUMENT);
818  RCL_CHECK_ALLOCATOR_WITH_MSG(&allocator, "invalid allocator", return RCL_RET_INVALID_ARGUMENT);
819  RCL_CHECK_ARGUMENT_FOR_NULL(nonros_argc, RCL_RET_INVALID_ARGUMENT);
820  RCL_CHECK_ARGUMENT_FOR_NULL(nonros_argv, RCL_RET_INVALID_ARGUMENT);
821  if (NULL != *nonros_argv) {
822  RCL_SET_ERROR_MSG("Output nonros_argv pointer is not null. May leak memory.");
824  }
825 
826  *nonros_argc = rcl_arguments_get_count_unparsed(args);
827  if (*nonros_argc < 0) {
828  RCL_SET_ERROR_MSG("Failed to get unparsed non ROS specific arguments count.");
830  } else if (*nonros_argc > 0) {
831  RCL_CHECK_ARGUMENT_FOR_NULL(argv, RCL_RET_INVALID_ARGUMENT);
832  }
833 
834  *nonros_argv = NULL;
835  if (0 == *nonros_argc) {
836  return RCL_RET_OK;
837  }
838 
839  int * unparsed_indices = NULL;
840  rcl_ret_t ret = rcl_arguments_get_unparsed(args, allocator, &unparsed_indices);
841 
842  if (RCL_RET_OK != ret) {
843  return ret;
844  }
845 
846  size_t alloc_size = sizeof(char *) * *nonros_argc;
847  *nonros_argv = allocator.allocate(alloc_size, allocator.state);
848  if (NULL == *nonros_argv) {
849  allocator.deallocate(unparsed_indices, allocator.state);
850  return RCL_RET_BAD_ALLOC;
851  }
852  for (int i = 0; i < *nonros_argc; ++i) {
853  (*nonros_argv)[i] = argv[unparsed_indices[i]];
854  }
855 
856  allocator.deallocate(unparsed_indices, allocator.state);
857  return RCL_RET_OK;
858 }
859 
860 rcl_ret_t
862  const rcl_arguments_t * args,
863  rcl_arguments_t * args_out)
864 {
865  RCUTILS_CAN_SET_MSG_AND_RETURN_WITH_ERROR_OF(RCL_RET_INVALID_ARGUMENT);
866  RCUTILS_CAN_SET_MSG_AND_RETURN_WITH_ERROR_OF(RCL_RET_BAD_ALLOC);
867 
868  RCL_CHECK_ARGUMENT_FOR_NULL(args, RCL_RET_INVALID_ARGUMENT);
869  RCL_CHECK_ARGUMENT_FOR_NULL(args->impl, RCL_RET_INVALID_ARGUMENT);
870  RCL_CHECK_ARGUMENT_FOR_NULL(args_out, RCL_RET_INVALID_ARGUMENT);
871  if (NULL != args_out->impl) {
872  RCL_SET_ERROR_MSG("args_out must be zero initialized");
874  }
875 
876  rcl_allocator_t allocator = args->impl->allocator;
877 
878  rcl_ret_t ret = _rcl_allocate_initialized_arguments_impl(args_out, &allocator);
879  if (RCL_RET_OK != ret) {
880  return ret;
881  }
882 
883  if (args->impl->num_unparsed_args) {
884  // Copy unparsed args
885  args_out->impl->unparsed_args = allocator.allocate(
886  sizeof(int) * args->impl->num_unparsed_args, allocator.state);
887  if (NULL == args_out->impl->unparsed_args) {
888  if (RCL_RET_OK != rcl_arguments_fini(args_out)) {
889  RCL_SET_ERROR_MSG("Error while finalizing arguments due to another error");
890  }
891  return RCL_RET_BAD_ALLOC;
892  }
893  for (int i = 0; i < args->impl->num_unparsed_args; ++i) {
894  args_out->impl->unparsed_args[i] = args->impl->unparsed_args[i];
895  }
896  args_out->impl->num_unparsed_args = args->impl->num_unparsed_args;
897  }
898 
899  if (args->impl->num_unparsed_ros_args) {
900  // Copy unparsed ROS args
901  args_out->impl->unparsed_ros_args = allocator.allocate(
902  sizeof(int) * args->impl->num_unparsed_ros_args, allocator.state);
903  if (NULL == args_out->impl->unparsed_ros_args) {
904  if (RCL_RET_OK != rcl_arguments_fini(args_out)) {
905  RCL_SET_ERROR_MSG("Error while finalizing arguments due to another error");
906  }
907  return RCL_RET_BAD_ALLOC;
908  }
909  for (int i = 0; i < args->impl->num_unparsed_ros_args; ++i) {
910  args_out->impl->unparsed_ros_args[i] = args->impl->unparsed_ros_args[i];
911  }
913  }
914 
915  if (args->impl->num_remap_rules) {
916  // Copy remap rules
917  args_out->impl->remap_rules = allocator.allocate(
918  sizeof(rcl_remap_t) * args->impl->num_remap_rules, allocator.state);
919  if (NULL == args_out->impl->remap_rules) {
920  if (RCL_RET_OK != rcl_arguments_fini(args_out)) {
921  RCL_SET_ERROR_MSG("Error while finalizing arguments due to another error");
922  }
923  return RCL_RET_BAD_ALLOC;
924  }
925  for (int i = 0; i < args->impl->num_remap_rules; ++i) {
927  ret = rcl_remap_copy(
928  &(args->impl->remap_rules[i]), &(args_out->impl->remap_rules[i]));
929  if (RCL_RET_OK != ret) {
930  if (RCL_RET_OK != rcl_arguments_fini(args_out)) {
931  RCL_SET_ERROR_MSG("Error while finalizing arguments due to another error");
932  }
933  return ret;
934  }
935  ++(args_out->impl->num_remap_rules);
936  }
937  }
938 
939  // Copy parameter rules
940  if (args->impl->parameter_overrides) {
941  args_out->impl->parameter_overrides =
942  rcl_yaml_node_struct_copy(args->impl->parameter_overrides);
943  }
944 
945  // Copy parameter files
946  if (args->impl->num_param_files_args) {
947  args_out->impl->parameter_files = allocator.zero_allocate(
948  args->impl->num_param_files_args, sizeof(char *), allocator.state);
949  if (NULL == args_out->impl->parameter_files) {
950  if (RCL_RET_OK != rcl_arguments_fini(args_out)) {
951  RCL_SET_ERROR_MSG("Error while finalizing arguments due to another error");
952  }
953  return RCL_RET_BAD_ALLOC;
954  }
955  for (int i = 0; i < args->impl->num_param_files_args; ++i) {
956  args_out->impl->parameter_files[i] =
957  rcutils_strdup(args->impl->parameter_files[i], allocator);
958  if (NULL == args_out->impl->parameter_files[i]) {
959  if (RCL_RET_OK != rcl_arguments_fini(args_out)) {
960  RCL_SET_ERROR_MSG("Error while finalizing arguments due to another error");
961  }
962  return RCL_RET_BAD_ALLOC;
963  }
964  ++(args_out->impl->num_param_files_args);
965  }
966  }
967  char * enclave_copy = rcutils_strdup(args->impl->enclave, allocator);
968  if (args->impl->enclave && !enclave_copy) {
969  if (RCL_RET_OK != rcl_arguments_fini(args_out)) {
970  RCL_SET_ERROR_MSG("Error while finalizing arguments due to another error");
971  } else {
972  RCL_SET_ERROR_MSG("Error while copying enclave argument");
973  }
974  return RCL_RET_BAD_ALLOC;
975  }
976  args_out->impl->enclave = enclave_copy;
977  return RCL_RET_OK;
978 }
979 
980 rcl_ret_t
982  rcl_arguments_t * args)
983 {
984  RCL_CHECK_ARGUMENT_FOR_NULL(args, RCL_RET_INVALID_ARGUMENT);
985  if (args->impl) {
986  rcl_ret_t ret = RCL_RET_OK;
987  if (args->impl->remap_rules) {
988  for (int i = 0; i < args->impl->num_remap_rules; ++i) {
989  rcl_ret_t remap_ret = rcl_remap_fini(&(args->impl->remap_rules[i]));
990  if (remap_ret != RCL_RET_OK) {
991  ret = remap_ret;
992  RCUTILS_LOG_ERROR_NAMED(
993  ROS_PACKAGE_NAME,
994  "Failed to finalize remap rule while finalizing arguments. Continuing...");
995  }
996  }
997  args->impl->allocator.deallocate(args->impl->remap_rules, args->impl->allocator.state);
998  args->impl->remap_rules = NULL;
999  args->impl->num_remap_rules = 0;
1000  }
1001 
1002  rcl_ret_t log_levels_ret = rcl_log_levels_fini(&args->impl->log_levels);
1003  if (log_levels_ret != RCL_RET_OK) {
1004  ret = log_levels_ret;
1005  RCUTILS_LOG_ERROR_NAMED(
1006  ROS_PACKAGE_NAME,
1007  "Failed to finalize log levels while finalizing arguments. Continuing...");
1008  }
1009 
1010  args->impl->allocator.deallocate(args->impl->unparsed_args, args->impl->allocator.state);
1011  args->impl->num_unparsed_args = 0;
1012  args->impl->unparsed_args = NULL;
1013 
1014  args->impl->allocator.deallocate(args->impl->unparsed_ros_args, args->impl->allocator.state);
1015  args->impl->num_unparsed_ros_args = 0;
1016  args->impl->unparsed_ros_args = NULL;
1017 
1018  if (args->impl->parameter_overrides) {
1019  rcl_yaml_node_struct_fini(args->impl->parameter_overrides);
1020  args->impl->parameter_overrides = NULL;
1021  }
1022 
1023  if (args->impl->parameter_files) {
1024  for (int p = 0; p < args->impl->num_param_files_args; ++p) {
1025  args->impl->allocator.deallocate(
1026  args->impl->parameter_files[p], args->impl->allocator.state);
1027  }
1028  args->impl->allocator.deallocate(args->impl->parameter_files, args->impl->allocator.state);
1029  args->impl->num_param_files_args = 0;
1030  args->impl->parameter_files = NULL;
1031  }
1032  args->impl->allocator.deallocate(args->impl->enclave, args->impl->allocator.state);
1033 
1034  if (NULL != args->impl->external_log_file_name_prefix) {
1035  args->impl->allocator.deallocate(
1036  args->impl->external_log_file_name_prefix, args->impl->allocator.state);
1037  args->impl->external_log_file_name_prefix = NULL;
1038  }
1039 
1040  if (NULL != args->impl->external_log_config_file) {
1041  args->impl->allocator.deallocate(
1042  args->impl->external_log_config_file, args->impl->allocator.state);
1043  args->impl->external_log_config_file = NULL;
1044  }
1045 
1046  args->impl->allocator.deallocate(args->impl, args->impl->allocator.state);
1047  args->impl = NULL;
1048  return ret;
1049  }
1050  RCL_SET_ERROR_MSG("rcl_arguments_t finalized twice");
1051  return RCL_RET_ERROR;
1052 }
1053 
1055 
1058 RCL_LOCAL
1059 rcl_ret_t
1060 _rcl_parse_remap_fully_qualified_namespace(
1061  rcl_lexer_lookahead2_t * lex_lookahead)
1062 {
1063  rcl_ret_t ret;
1064 
1065  // Check arguments sanity
1066  assert(NULL != lex_lookahead);
1067 
1068  // Must have at least one Forward slash /
1069  ret = rcl_lexer_lookahead2_expect(lex_lookahead, RCL_LEXEME_FORWARD_SLASH, NULL, NULL);
1070  if (RCL_RET_WRONG_LEXEME == ret) {
1072  }
1073 
1074  // repeated tokens and slashes (allow trailing slash, but don't require it)
1075  while (true) {
1076  ret = rcl_lexer_lookahead2_expect(lex_lookahead, RCL_LEXEME_TOKEN, NULL, NULL);
1077  if (RCL_RET_WRONG_LEXEME == ret) {
1078  rcl_reset_error();
1079  break;
1080  }
1081  ret = rcl_lexer_lookahead2_expect(lex_lookahead, RCL_LEXEME_FORWARD_SLASH, NULL, NULL);
1082  if (RCL_RET_WRONG_LEXEME == ret) {
1083  rcl_reset_error();
1084  break;
1085  }
1086  }
1087  return RCL_RET_OK;
1088 }
1089 
1091 
1094 RCL_LOCAL
1095 rcl_ret_t
1096 _rcl_parse_remap_replacement_token(rcl_lexer_lookahead2_t * lex_lookahead)
1097 {
1098  rcl_ret_t ret;
1099  rcl_lexeme_t lexeme;
1100 
1101  // Check arguments sanity
1102  assert(NULL != lex_lookahead);
1103 
1104  ret = rcl_lexer_lookahead2_peek(lex_lookahead, &lexeme);
1105  if (RCL_RET_OK != ret) {
1106  return ret;
1107  }
1108 
1109  if (
1110  RCL_LEXEME_BR1 == lexeme || RCL_LEXEME_BR2 == lexeme || RCL_LEXEME_BR3 == lexeme ||
1111  RCL_LEXEME_BR4 == lexeme || RCL_LEXEME_BR5 == lexeme || RCL_LEXEME_BR6 == lexeme ||
1112  RCL_LEXEME_BR7 == lexeme || RCL_LEXEME_BR8 == lexeme || RCL_LEXEME_BR9 == lexeme)
1113  {
1114  RCL_SET_ERROR_MSG("Backreferences are not implemented");
1115  return RCL_RET_ERROR;
1116  } else if (RCL_LEXEME_TOKEN == lexeme) {
1117  ret = rcl_lexer_lookahead2_accept(lex_lookahead, NULL, NULL);
1118  } else {
1120  }
1121 
1122  return ret;
1123 }
1124 
1126 
1129 RCL_LOCAL
1130 rcl_ret_t
1131 _rcl_parse_remap_replacement_name(
1132  rcl_lexer_lookahead2_t * lex_lookahead,
1133  rcl_remap_t * rule)
1134 {
1135  rcl_ret_t ret;
1136  rcl_lexeme_t lexeme;
1137 
1138  // Check arguments sanity
1139  assert(NULL != lex_lookahead);
1140  assert(NULL != rule);
1141 
1142  const char * replacement_start = rcl_lexer_lookahead2_get_text(lex_lookahead);
1143  if (NULL == replacement_start) {
1144  RCL_SET_ERROR_MSG("failed to get start of replacement");
1145  return RCL_RET_ERROR;
1146  }
1147 
1148  // private name (~/...) or fully qualified name (/...) ?
1149  ret = rcl_lexer_lookahead2_peek(lex_lookahead, &lexeme);
1150  if (RCL_RET_OK != ret) {
1151  return ret;
1152  }
1153  if (RCL_LEXEME_TILDE_SLASH == lexeme || RCL_LEXEME_FORWARD_SLASH == lexeme) {
1154  ret = rcl_lexer_lookahead2_accept(lex_lookahead, NULL, NULL);
1155  }
1156  if (RCL_RET_OK != ret) {
1157  return ret;
1158  }
1159 
1160  // token ( '/' token )*
1161  ret = _rcl_parse_remap_replacement_token(lex_lookahead);
1162  if (RCL_RET_OK != ret) {
1163  return ret;
1164  }
1165  ret = rcl_lexer_lookahead2_peek(lex_lookahead, &lexeme);
1166  if (RCL_RET_OK != ret) {
1167  return ret;
1168  }
1169  while (RCL_LEXEME_EOF != lexeme) {
1170  ret = rcl_lexer_lookahead2_expect(lex_lookahead, RCL_LEXEME_FORWARD_SLASH, NULL, NULL);
1171  if (RCL_RET_WRONG_LEXEME == ret) {
1173  }
1174  ret = _rcl_parse_remap_replacement_token(lex_lookahead);
1175  if (RCL_RET_OK != ret) {
1176  return ret;
1177  }
1178  ret = rcl_lexer_lookahead2_peek(lex_lookahead, &lexeme);
1179  if (RCL_RET_OK != ret) {
1180  return ret;
1181  }
1182  }
1183 
1184  // Copy replacement into rule
1185  const char * replacement_end = rcl_lexer_lookahead2_get_text(lex_lookahead);
1186  size_t length = (size_t)(replacement_end - replacement_start);
1187  rule->impl->replacement = rcutils_strndup(
1188  replacement_start, length, rule->impl->allocator);
1189  if (NULL == rule->impl->replacement) {
1190  RCL_SET_ERROR_MSG("failed to copy replacement");
1191  return RCL_RET_BAD_ALLOC;
1192  }
1193 
1194  return RCL_RET_OK;
1195 }
1196 
1198 
1201 RCL_LOCAL
1202 rcl_ret_t
1203 _rcl_parse_resource_match_token(rcl_lexer_lookahead2_t * lex_lookahead)
1204 {
1205  rcl_ret_t ret;
1206  rcl_lexeme_t lexeme;
1207 
1208  // Check arguments sanity
1209  assert(NULL != lex_lookahead);
1210 
1211  ret = rcl_lexer_lookahead2_peek(lex_lookahead, &lexeme);
1212  if (RCL_RET_OK != ret) {
1213  return ret;
1214  }
1215 
1216  if (RCL_LEXEME_TOKEN == lexeme) {
1217  ret = rcl_lexer_lookahead2_accept(lex_lookahead, NULL, NULL);
1218  } else if (RCL_LEXEME_WILD_ONE == lexeme) {
1219  RCL_SET_ERROR_MSG("Wildcard '*' is not implemented");
1220  ret = RCL_RET_ERROR;
1221  } else if (RCL_LEXEME_WILD_MULTI == lexeme) {
1222  RCL_SET_ERROR_MSG("Wildcard '**' is not implemented");
1223  ret = RCL_RET_ERROR;
1224  } else {
1225  RCL_SET_ERROR_MSG("Expecting token or wildcard");
1226  ret = RCL_RET_WRONG_LEXEME;
1227  }
1228 
1229  return ret;
1230 }
1231 
1233 
1236 RCL_LOCAL
1237 rcl_ret_t
1238 _rcl_parse_resource_match(
1239  rcl_lexer_lookahead2_t * lex_lookahead,
1240  rcl_allocator_t allocator,
1241  char ** resource_match)
1242 {
1243  rcl_ret_t ret;
1244  rcl_lexeme_t lexeme;
1245 
1246  // Check arguments sanity
1247  assert(NULL != lex_lookahead);
1248  assert(rcutils_allocator_is_valid(&allocator));
1249  assert(NULL != resource_match);
1250  assert(NULL == *resource_match);
1251 
1252  const char * match_start = rcl_lexer_lookahead2_get_text(lex_lookahead);
1253  if (NULL == match_start) {
1254  RCL_SET_ERROR_MSG("failed to get start of match");
1255  return RCL_RET_ERROR;
1256  }
1257 
1258  // private name (~/...) or fully qualified name (/...) ?
1259  ret = rcl_lexer_lookahead2_peek(lex_lookahead, &lexeme);
1260  if (RCL_RET_OK != ret) {
1261  return ret;
1262  }
1263  if (RCL_LEXEME_TILDE_SLASH == lexeme || RCL_LEXEME_FORWARD_SLASH == lexeme) {
1264  ret = rcl_lexer_lookahead2_accept(lex_lookahead, NULL, NULL);
1265  if (RCL_RET_OK != ret) {
1266  return ret;
1267  }
1268  }
1269 
1270  // token ( '/' token )*
1271  ret = _rcl_parse_resource_match_token(lex_lookahead);
1272  if (RCL_RET_OK != ret) {
1273  return ret;
1274  }
1275  ret = rcl_lexer_lookahead2_peek(lex_lookahead, &lexeme);
1276  if (RCL_RET_OK != ret) {
1277  return ret;
1278  }
1279  while (RCL_LEXEME_SEPARATOR != lexeme) {
1280  ret = rcl_lexer_lookahead2_expect(lex_lookahead, RCL_LEXEME_FORWARD_SLASH, NULL, NULL);
1281  if (RCL_RET_WRONG_LEXEME == ret) {
1283  } else if (RCL_RET_OK != ret) {
1284  // Another failure
1285  return ret;
1286  }
1287  ret = _rcl_parse_resource_match_token(lex_lookahead);
1288  if (RCL_RET_OK != ret) {
1289  return ret;
1290  }
1291  ret = rcl_lexer_lookahead2_peek(lex_lookahead, &lexeme);
1292  if (RCL_RET_OK != ret) {
1293  return ret;
1294  }
1295  }
1296 
1297  // Copy match into rule
1298  const char * match_end = rcl_lexer_lookahead2_get_text(lex_lookahead);
1299  const size_t length = (size_t)(match_end - match_start);
1300  *resource_match = rcutils_strndup(match_start, length, allocator);
1301  if (NULL == *resource_match) {
1302  RCL_SET_ERROR_MSG("failed to copy match");
1303  return RCL_RET_BAD_ALLOC;
1304  }
1305 
1306  return RCL_RET_OK;
1307 }
1308 
1309 RCL_LOCAL
1310 rcl_ret_t
1311 _rcl_parse_param_name_token(rcl_lexer_lookahead2_t * lex_lookahead)
1312 {
1313  rcl_ret_t ret;
1314  rcl_lexeme_t lexeme;
1315 
1316  // Check arguments sanity
1317  assert(NULL != lex_lookahead);
1318 
1319  ret = rcl_lexer_lookahead2_peek(lex_lookahead, &lexeme);
1320  if (RCL_RET_OK != ret) {
1321  return ret;
1322  }
1323  if (RCL_LEXEME_TOKEN != lexeme && RCL_LEXEME_FORWARD_SLASH != lexeme) {
1324  if (RCL_LEXEME_WILD_ONE == lexeme) {
1325  RCL_SET_ERROR_MSG("Wildcard '*' is not implemented");
1326  return RCL_RET_ERROR;
1327  } else if (RCL_LEXEME_WILD_MULTI == lexeme) {
1328  RCL_SET_ERROR_MSG("Wildcard '**' is not implemented");
1329  return RCL_RET_ERROR;
1330  } else {
1331  RCL_SET_ERROR_MSG("Expecting token or wildcard");
1332  return RCL_RET_WRONG_LEXEME;
1333  }
1334  }
1335  do {
1336  ret = rcl_lexer_lookahead2_accept(lex_lookahead, NULL, NULL);
1337  if (RCL_RET_OK != ret) {
1338  return ret;
1339  }
1340  ret = rcl_lexer_lookahead2_peek(lex_lookahead, &lexeme);
1341  if (RCL_RET_OK != ret) {
1342  return ret;
1343  }
1344  } while (RCL_LEXEME_TOKEN == lexeme || RCL_LEXEME_FORWARD_SLASH == lexeme);
1345  return RCL_RET_OK;
1346 }
1347 
1349 
1352 // TODO(hidmic): remove when parameter names are standardized to use slashes
1353 // in lieu of dots.
1354 RCL_LOCAL
1355 rcl_ret_t
1356 _rcl_parse_param_name(
1357  rcl_lexer_lookahead2_t * lex_lookahead,
1358  rcl_allocator_t allocator,
1359  char ** param_name)
1360 {
1361  rcl_ret_t ret;
1362  rcl_lexeme_t lexeme;
1363 
1364  // Check arguments sanity
1365  assert(NULL != lex_lookahead);
1366  assert(rcutils_allocator_is_valid(&allocator));
1367  assert(NULL != param_name);
1368  assert(NULL == *param_name);
1369 
1370  const char * name_start = rcl_lexer_lookahead2_get_text(lex_lookahead);
1371  if (NULL == name_start) {
1372  RCL_SET_ERROR_MSG("failed to get start of param name");
1373  return RCL_RET_ERROR;
1374  }
1375 
1376  // token ( '.' token )*
1377  ret = _rcl_parse_param_name_token(lex_lookahead);
1378  if (RCL_RET_OK != ret) {
1379  return ret;
1380  }
1381  ret = rcl_lexer_lookahead2_peek(lex_lookahead, &lexeme);
1382  if (RCL_RET_OK != ret) {
1383  return ret;
1384  }
1385  while (RCL_LEXEME_SEPARATOR != lexeme) {
1386  ret = rcl_lexer_lookahead2_expect(lex_lookahead, RCL_LEXEME_DOT, NULL, NULL);
1387  if (RCL_RET_WRONG_LEXEME == ret) {
1389  }
1390  ret = _rcl_parse_param_name_token(lex_lookahead);
1391  if (RCL_RET_OK != ret) {
1392  return ret;
1393  }
1394  ret = rcl_lexer_lookahead2_peek(lex_lookahead, &lexeme);
1395  if (RCL_RET_OK != ret) {
1396  return ret;
1397  }
1398  }
1399 
1400  // Copy param name
1401  const char * name_end = rcl_lexer_lookahead2_get_text(lex_lookahead);
1402  const size_t length = (size_t)(name_end - name_start);
1403  *param_name = rcutils_strndup(name_start, length, allocator);
1404  if (NULL == *param_name) {
1405  RCL_SET_ERROR_MSG("failed to copy param name");
1406  return RCL_RET_BAD_ALLOC;
1407  }
1408 
1409  return RCL_RET_OK;
1410 }
1411 
1412 
1414 
1417 RCL_LOCAL
1418 rcl_ret_t
1419 _rcl_parse_remap_match_name(
1420  rcl_lexer_lookahead2_t * lex_lookahead,
1421  rcl_remap_t * rule)
1422 {
1423  rcl_ret_t ret;
1424  rcl_lexeme_t lexeme;
1425 
1426  // Check arguments sanity
1427  assert(NULL != lex_lookahead);
1428  assert(NULL != rule);
1429 
1430  // rostopic:// rosservice://
1431  ret = rcl_lexer_lookahead2_peek(lex_lookahead, &lexeme);
1432  if (RCL_RET_OK != ret) {
1433  return ret;
1434  }
1435  if (RCL_LEXEME_URL_SERVICE == lexeme) {
1436  rule->impl->type = RCL_SERVICE_REMAP;
1437  ret = rcl_lexer_lookahead2_accept(lex_lookahead, NULL, NULL);
1438  } else if (RCL_LEXEME_URL_TOPIC == lexeme) {
1439  rule->impl->type = RCL_TOPIC_REMAP;
1440  ret = rcl_lexer_lookahead2_accept(lex_lookahead, NULL, NULL);
1441  } else {
1442  rule->impl->type = (RCL_TOPIC_REMAP | RCL_SERVICE_REMAP);
1443  }
1444  if (RCL_RET_OK != ret) {
1445  return ret;
1446  }
1447 
1448  ret = _rcl_parse_resource_match(
1449  lex_lookahead, rule->impl->allocator, &rule->impl->match);
1450  if (RCL_RET_WRONG_LEXEME == ret) {
1452  }
1453  return ret;
1454 }
1455 
1457 
1460 RCL_LOCAL
1461 rcl_ret_t
1462 _rcl_parse_remap_name_remap(
1463  rcl_lexer_lookahead2_t * lex_lookahead,
1464  rcl_remap_t * rule)
1465 {
1466  rcl_ret_t ret;
1467 
1468  // Check arguments sanity
1469  assert(NULL != lex_lookahead);
1470  assert(NULL != rule);
1471 
1472  // match
1473  ret = _rcl_parse_remap_match_name(lex_lookahead, rule);
1474  if (RCL_RET_OK != ret) {
1475  return ret;
1476  }
1477  // :=
1478  ret = rcl_lexer_lookahead2_expect(lex_lookahead, RCL_LEXEME_SEPARATOR, NULL, NULL);
1479  if (RCL_RET_WRONG_LEXEME == ret) {
1481  }
1482  // replacement
1483  ret = _rcl_parse_remap_replacement_name(lex_lookahead, rule);
1484  if (RCL_RET_OK != ret) {
1485  return ret;
1486  }
1487 
1488  return RCL_RET_OK;
1489 }
1490 
1492 
1495 RCL_LOCAL
1496 rcl_ret_t
1497 _rcl_parse_remap_namespace_replacement(
1498  rcl_lexer_lookahead2_t * lex_lookahead,
1499  rcl_remap_t * rule)
1500 {
1501  rcl_ret_t ret;
1502 
1503  // Check arguments sanity
1504  assert(NULL != lex_lookahead);
1505  assert(NULL != rule);
1506 
1507  // __ns
1508  ret = rcl_lexer_lookahead2_expect(lex_lookahead, RCL_LEXEME_NS, NULL, NULL);
1509  if (RCL_RET_WRONG_LEXEME == ret) {
1511  }
1512  // :=
1513  ret = rcl_lexer_lookahead2_expect(lex_lookahead, RCL_LEXEME_SEPARATOR, NULL, NULL);
1514  if (RCL_RET_WRONG_LEXEME == ret) {
1516  }
1517  // /foo/bar
1518  const char * ns_start = rcl_lexer_lookahead2_get_text(lex_lookahead);
1519  if (NULL == ns_start) {
1520  RCL_SET_ERROR_MSG("failed to get start of namespace");
1521  return RCL_RET_ERROR;
1522  }
1523  ret = _rcl_parse_remap_fully_qualified_namespace(lex_lookahead);
1524  if (RCL_RET_OK != ret) {
1525  if (RCL_RET_INVALID_REMAP_RULE == ret) {
1526  // The name didn't start with a leading forward slash
1527  RCUTILS_LOG_WARN_NAMED(
1528  ROS_PACKAGE_NAME, "Namespace not remapped to a fully qualified name (found: %s)", ns_start);
1529  }
1530  return ret;
1531  }
1532  // There should be nothing left
1533  ret = rcl_lexer_lookahead2_expect(lex_lookahead, RCL_LEXEME_EOF, NULL, NULL);
1534  if (RCL_RET_OK != ret) {
1535  // The name must have started with a leading forward slash but had an otherwise invalid format
1536  RCUTILS_LOG_WARN_NAMED(
1537  ROS_PACKAGE_NAME, "Namespace not remapped to a fully qualified name (found: %s)", ns_start);
1538  return ret;
1539  }
1540 
1541  // Copy namespace into rule
1542  const char * ns_end = rcl_lexer_lookahead2_get_text(lex_lookahead);
1543  size_t length = (size_t)(ns_end - ns_start);
1544  rule->impl->replacement = rcutils_strndup(ns_start, length, rule->impl->allocator);
1545  if (NULL == rule->impl->replacement) {
1546  RCL_SET_ERROR_MSG("failed to copy namespace");
1547  return RCL_RET_BAD_ALLOC;
1548  }
1549 
1550  rule->impl->type = RCL_NAMESPACE_REMAP;
1551  return RCL_RET_OK;
1552 }
1553 
1555 
1558 RCL_LOCAL
1559 rcl_ret_t
1560 _rcl_parse_remap_nodename_replacement(
1561  rcl_lexer_lookahead2_t * lex_lookahead,
1562  rcl_remap_t * rule)
1563 {
1564  rcl_ret_t ret;
1565  const char * node_name;
1566  size_t length;
1567 
1568  // Check arguments sanity
1569  assert(NULL != lex_lookahead);
1570  assert(NULL != rule);
1571 
1572  // __node
1573  ret = rcl_lexer_lookahead2_expect(lex_lookahead, RCL_LEXEME_NODE, NULL, NULL);
1574  if (RCL_RET_WRONG_LEXEME == ret) {
1576  }
1577  // :=
1578  ret = rcl_lexer_lookahead2_expect(lex_lookahead, RCL_LEXEME_SEPARATOR, NULL, NULL);
1579  if (RCL_RET_WRONG_LEXEME == ret) {
1581  }
1582  // new_node_name
1583  ret = rcl_lexer_lookahead2_expect(lex_lookahead, RCL_LEXEME_TOKEN, &node_name, &length);
1584  if (RCL_RET_WRONG_LEXEME == ret) {
1585  node_name = rcl_lexer_lookahead2_get_text(lex_lookahead);
1586  RCUTILS_LOG_WARN_NAMED(
1587  ROS_PACKAGE_NAME, "Node name not remapped to invalid name: '%s'", node_name);
1589  }
1590  if (RCL_RET_OK != ret) {
1591  return ret;
1592  }
1593  // copy the node name into the replacement side of the rule
1594  rule->impl->replacement = rcutils_strndup(node_name, length, rule->impl->allocator);
1595  if (NULL == rule->impl->replacement) {
1596  RCL_SET_ERROR_MSG("failed to allocate node name");
1597  return RCL_RET_BAD_ALLOC;
1598  }
1599 
1600  rule->impl->type = RCL_NODENAME_REMAP;
1601  return RCL_RET_OK;
1602 }
1603 
1605 RCL_LOCAL
1606 rcl_ret_t
1607 _rcl_parse_nodename_prefix(
1608  rcl_lexer_lookahead2_t * lex_lookahead,
1609  rcl_allocator_t allocator,
1610  char ** node_name)
1611 {
1612  size_t length = 0;
1613  const char * token = NULL;
1614 
1615  // Check arguments sanity
1616  assert(NULL != lex_lookahead);
1617  assert(rcutils_allocator_is_valid(&allocator));
1618  assert(NULL != node_name);
1619  assert(NULL == *node_name);
1620 
1621  // Expect a token and a colon
1622  rcl_ret_t ret =
1623  rcl_lexer_lookahead2_expect(lex_lookahead, RCL_LEXEME_TOKEN, &token, &length);
1624  if (RCL_RET_OK != ret) {
1625  return ret;
1626  }
1627  ret = rcl_lexer_lookahead2_expect(lex_lookahead, RCL_LEXEME_COLON, NULL, NULL);
1628  if (RCL_RET_OK != ret) {
1629  return ret;
1630  }
1631 
1632  // Copy the node name
1633  *node_name = rcutils_strndup(token, length, allocator);
1634  if (NULL == *node_name) {
1635  RCL_SET_ERROR_MSG("failed to allocate node name");
1636  return RCL_RET_BAD_ALLOC;
1637  }
1638 
1639  return RCL_RET_OK;
1640 }
1641 
1643 
1647 RCL_LOCAL
1648 rcl_ret_t
1649 _rcl_parse_remap_nodename_prefix(
1650  rcl_lexer_lookahead2_t * lex_lookahead,
1651  rcl_remap_t * rule)
1652 {
1653  // Check arguments sanity
1654  assert(NULL != lex_lookahead);
1655  assert(NULL != rule);
1656 
1657  rcl_ret_t ret = _rcl_parse_nodename_prefix(
1658  lex_lookahead, rule->impl->allocator, &rule->impl->node_name);
1659  if (RCL_RET_WRONG_LEXEME == ret) {
1661  }
1662  return ret;
1663 }
1664 
1666 
1674 RCL_LOCAL
1675 rcl_ret_t
1676 _rcl_parse_remap_begin_remap_rule(
1677  rcl_lexer_lookahead2_t * lex_lookahead,
1678  rcl_remap_t * rule)
1679 {
1680  rcl_ret_t ret;
1681  rcl_lexeme_t lexeme1;
1682  rcl_lexeme_t lexeme2;
1683 
1684  // Check arguments sanity
1685  assert(NULL != lex_lookahead);
1686  assert(NULL != rule);
1687 
1688  // Check for optional nodename prefix
1689  ret = rcl_lexer_lookahead2_peek2(lex_lookahead, &lexeme1, &lexeme2);
1690  if (RCL_RET_OK != ret) {
1691  return ret;
1692  }
1693  if (RCL_LEXEME_TOKEN == lexeme1 && RCL_LEXEME_COLON == lexeme2) {
1694  ret = _rcl_parse_remap_nodename_prefix(lex_lookahead, rule);
1695  if (RCL_RET_OK != ret) {
1696  return ret;
1697  }
1698  }
1699 
1700  ret = rcl_lexer_lookahead2_peek(lex_lookahead, &lexeme1);
1701  if (RCL_RET_OK != ret) {
1702  return ret;
1703  }
1704 
1705  // What type of rule is this (node name replacement, namespace replacement, or name remap)?
1706  if (RCL_LEXEME_NODE == lexeme1) {
1707  ret = _rcl_parse_remap_nodename_replacement(lex_lookahead, rule);
1708  if (RCL_RET_OK != ret) {
1709  return ret;
1710  }
1711  } else if (RCL_LEXEME_NS == lexeme1) {
1712  ret = _rcl_parse_remap_namespace_replacement(lex_lookahead, rule);
1713  if (RCL_RET_OK != ret) {
1714  return ret;
1715  }
1716  } else {
1717  ret = _rcl_parse_remap_name_remap(lex_lookahead, rule);
1718  if (RCL_RET_OK != ret) {
1719  return ret;
1720  }
1721  }
1722 
1723  // Make sure all characters in string have been consumed
1724  ret = rcl_lexer_lookahead2_expect(lex_lookahead, RCL_LEXEME_EOF, NULL, NULL);
1725  if (RCL_RET_WRONG_LEXEME == ret) {
1727  }
1728  return ret;
1729 }
1730 
1731 RCL_LOCAL
1732 rcl_ret_t
1733 _rcl_parse_log_level_name(
1734  rcl_lexer_lookahead2_t * lex_lookahead,
1735  rcl_allocator_t * allocator,
1736  char ** logger_name)
1737 {
1738  rcl_lexeme_t lexeme;
1739 
1740  // Check arguments sanity
1741  assert(NULL != lex_lookahead);
1742  assert(rcutils_allocator_is_valid(allocator));
1743  assert(NULL != logger_name);
1744  assert(NULL == *logger_name);
1745 
1746  const char * name_start = rcl_lexer_lookahead2_get_text(lex_lookahead);
1747  if (NULL == name_start) {
1748  RCL_SET_ERROR_MSG("failed to get start of logger name");
1749  return RCL_RET_ERROR;
1750  }
1751 
1752  rcl_ret_t ret = rcl_lexer_lookahead2_peek(lex_lookahead, &lexeme);
1753  if (RCL_RET_OK != ret) {
1754  return ret;
1755  }
1756 
1757  while (RCL_LEXEME_SEPARATOR != lexeme) {
1758  ret = rcl_lexer_lookahead2_expect(lex_lookahead, lexeme, NULL, NULL);
1759  if (RCL_RET_OK != ret) {
1760  return ret;
1761  }
1762 
1763  ret = rcl_lexer_lookahead2_peek(lex_lookahead, &lexeme);
1764  if (RCL_RET_OK != ret) {
1765  return ret;
1766  }
1767 
1768  if (lexeme == RCL_LEXEME_EOF) {
1770  return ret;
1771  }
1772  }
1773 
1774  // Copy logger name
1775  const char * name_end = rcl_lexer_lookahead2_get_text(lex_lookahead);
1776  const size_t length = (size_t)(name_end - name_start);
1777  *logger_name = rcutils_strndup(name_start, length, *allocator);
1778  if (NULL == *logger_name) {
1779  RCL_SET_ERROR_MSG("failed to copy logger name");
1780  return RCL_RET_BAD_ALLOC;
1781  }
1782 
1783  return RCL_RET_OK;
1784 }
1785 
1786 rcl_ret_t
1787 _rcl_parse_log_level(
1788  const char * arg,
1789  rcl_log_levels_t * log_levels)
1790 {
1791  RCL_CHECK_ARGUMENT_FOR_NULL(arg, RCL_RET_INVALID_ARGUMENT);
1792  RCL_CHECK_ARGUMENT_FOR_NULL(log_levels, RCL_RET_INVALID_ARGUMENT);
1793  RCL_CHECK_ARGUMENT_FOR_NULL(log_levels->logger_settings, RCL_RET_INVALID_ARGUMENT);
1794  rcl_allocator_t * allocator = &log_levels->allocator;
1795  RCL_CHECK_ALLOCATOR_WITH_MSG(allocator, "invalid allocator", return RCL_RET_INVALID_ARGUMENT);
1796 
1797  rcl_ret_t ret = RCL_RET_OK;
1798  char * logger_name = NULL;
1799  int level = 0;
1800  rcutils_ret_t rcutils_ret = RCUTILS_RET_OK;
1801 
1803 
1804  ret = rcl_lexer_lookahead2_init(&lex_lookahead, arg, *allocator);
1805  if (RCL_RET_OK != ret) {
1806  return ret;
1807  }
1808 
1809  ret = _rcl_parse_log_level_name(&lex_lookahead, allocator, &logger_name);
1810  if (RCL_RET_OK == ret) {
1811  if (strlen(logger_name) == 0) {
1812  RCL_SET_ERROR_MSG("Argument has an invalid logger item that name is empty");
1814  goto cleanup;
1815  }
1816 
1817  ret = rcl_lexer_lookahead2_expect(&lex_lookahead, RCL_LEXEME_SEPARATOR, NULL, NULL);
1818  if (RCL_RET_WRONG_LEXEME == ret) {
1820  goto cleanup;
1821  }
1822 
1823  const char * level_token;
1824  size_t level_token_length;
1826  &lex_lookahead, RCL_LEXEME_TOKEN, &level_token, &level_token_length);
1827  if (RCL_RET_WRONG_LEXEME == ret) {
1829  goto cleanup;
1830  }
1831 
1832  ret = rcl_lexer_lookahead2_expect(&lex_lookahead, RCL_LEXEME_EOF, NULL, NULL);
1833  if (RCL_RET_OK != ret) {
1835  goto cleanup;
1836  }
1837 
1838  rcutils_ret = rcutils_logging_severity_level_from_string(
1839  level_token, *allocator, &level);
1840  if (RCUTILS_RET_OK == rcutils_ret) {
1842  log_levels, logger_name, (rcl_log_severity_t)level);
1843  if (ret != RCL_RET_OK) {
1844  goto cleanup;
1845  }
1846  }
1847  } else {
1848  rcutils_ret = rcutils_logging_severity_level_from_string(
1849  arg, *allocator, &level);
1850  if (RCUTILS_RET_OK == rcutils_ret) {
1851  if (log_levels->default_logger_level != (rcl_log_severity_t)level) {
1852  if (log_levels->default_logger_level != RCUTILS_LOG_SEVERITY_UNSET) {
1853  RCUTILS_LOG_DEBUG_NAMED(
1854  ROS_PACKAGE_NAME, "Minimum default log level will be replaced from %d to %d",
1855  log_levels->default_logger_level, level);
1856  }
1857  log_levels->default_logger_level = (rcl_log_severity_t)level;
1858  }
1859  ret = RCL_RET_OK;
1860  }
1861  }
1862 
1863  if (RCUTILS_RET_OK != rcutils_ret) {
1864  RCL_SET_ERROR_MSG("Argument does not use a valid severity level");
1865  ret = RCL_RET_ERROR;
1866  }
1867 
1868 cleanup:
1869  if (logger_name) {
1870  allocator->deallocate(logger_name, allocator->state);
1871  }
1872  rcl_ret_t rv = rcl_lexer_lookahead2_fini(&lex_lookahead);
1873  if (RCL_RET_OK != rv) {
1874  if (RCL_RET_OK != ret) {
1875  RCUTILS_LOG_ERROR_NAMED(ROS_PACKAGE_NAME, "Failed to fini lookahead2 after error occurred");
1876  } else {
1877  ret = rv;
1878  }
1879  }
1880 
1881  return ret;
1882 }
1883 
1884 rcl_ret_t
1885 _rcl_parse_remap_rule(
1886  const char * arg,
1887  rcl_allocator_t allocator,
1888  rcl_remap_t * output_rule)
1889 {
1890  RCL_CHECK_ARGUMENT_FOR_NULL(arg, RCL_RET_INVALID_ARGUMENT);
1891  RCL_CHECK_ARGUMENT_FOR_NULL(output_rule, RCL_RET_INVALID_ARGUMENT);
1892 
1893  output_rule->impl =
1894  allocator.allocate(sizeof(rcl_remap_impl_t), allocator.state);
1895  if (NULL == output_rule->impl) {
1896  return RCL_RET_BAD_ALLOC;
1897  }
1898  output_rule->impl->allocator = allocator;
1899  output_rule->impl->type = RCL_UNKNOWN_REMAP;
1900  output_rule->impl->node_name = NULL;
1901  output_rule->impl->match = NULL;
1902  output_rule->impl->replacement = NULL;
1903 
1905  rcl_ret_t ret = rcl_lexer_lookahead2_init(&lex_lookahead, arg, allocator);
1906 
1907  if (RCL_RET_OK == ret) {
1908  ret = _rcl_parse_remap_begin_remap_rule(&lex_lookahead, output_rule);
1909 
1910  rcl_ret_t fini_ret = rcl_lexer_lookahead2_fini(&lex_lookahead);
1911  if (RCL_RET_OK != ret) {
1912  if (RCL_RET_OK != fini_ret) {
1913  RCUTILS_LOG_ERROR_NAMED(
1914  ROS_PACKAGE_NAME, "Failed to fini lookahead2 after error occurred");
1915  }
1916  } else {
1917  if (RCL_RET_OK == fini_ret) {
1918  return RCL_RET_OK;
1919  }
1920  ret = fini_ret;
1921  }
1922  }
1923 
1924  // cleanup output rule but keep first error return code
1925  if (RCL_RET_OK != rcl_remap_fini(output_rule)) {
1926  RCUTILS_LOG_ERROR_NAMED(
1927  ROS_PACKAGE_NAME, "Failed to fini remap rule after error occurred");
1928  }
1929 
1930  return ret;
1931 }
1932 
1933 rcl_ret_t
1934 _rcl_parse_param_rule(
1935  const char * arg,
1936  rcl_params_t * params)
1937 {
1938  RCL_CHECK_ARGUMENT_FOR_NULL(arg, RCL_RET_INVALID_ARGUMENT);
1939  RCL_CHECK_ARGUMENT_FOR_NULL(params, RCL_RET_INVALID_ARGUMENT);
1940 
1942 
1943  rcl_ret_t ret = rcl_lexer_lookahead2_init(&lex_lookahead, arg, params->allocator);
1944  if (RCL_RET_OK != ret) {
1945  return ret;
1946  }
1947 
1948  rcl_lexeme_t lexeme1;
1949  rcl_lexeme_t lexeme2;
1950  char * node_name = NULL;
1951  char * param_name = NULL;
1952 
1953  // Check for optional nodename prefix
1954  ret = rcl_lexer_lookahead2_peek2(&lex_lookahead, &lexeme1, &lexeme2);
1955  if (RCL_RET_OK != ret) {
1956  goto cleanup;
1957  }
1958 
1959  if (RCL_LEXEME_TOKEN == lexeme1 && RCL_LEXEME_COLON == lexeme2) {
1960  ret = _rcl_parse_nodename_prefix(&lex_lookahead, params->allocator, &node_name);
1961  if (RCL_RET_OK != ret) {
1962  if (RCL_RET_WRONG_LEXEME == ret) {
1964  }
1965  goto cleanup;
1966  }
1967  } else {
1968  node_name = rcutils_strdup("/**", params->allocator);
1969  if (NULL == node_name) {
1970  ret = RCL_RET_BAD_ALLOC;
1971  goto cleanup;
1972  }
1973  }
1974 
1975  // TODO(hidmic): switch to _rcl_parse_resource_match() when parameter names
1976  // are standardized to use slashes in lieu of dots.
1977  ret = _rcl_parse_param_name(&lex_lookahead, params->allocator, &param_name);
1978  if (RCL_RET_OK != ret) {
1979  if (RCL_RET_WRONG_LEXEME == ret) {
1981  }
1982  goto cleanup;
1983  }
1984 
1985  ret = rcl_lexer_lookahead2_expect(&lex_lookahead, RCL_LEXEME_SEPARATOR, NULL, NULL);
1986  if (RCL_RET_WRONG_LEXEME == ret) {
1988  goto cleanup;
1989  }
1990 
1991  const char * yaml_value = rcl_lexer_lookahead2_get_text(&lex_lookahead);
1992  if (!rcl_parse_yaml_value(node_name, param_name, yaml_value, params)) {
1994  goto cleanup;
1995  }
1996 
1997 cleanup:
1998  params->allocator.deallocate(param_name, params->allocator.state);
1999  params->allocator.deallocate(node_name, params->allocator.state);
2000  if (RCL_RET_OK != ret) {
2001  if (RCL_RET_OK != rcl_lexer_lookahead2_fini(&lex_lookahead)) {
2002  RCUTILS_LOG_ERROR_NAMED(ROS_PACKAGE_NAME, "Failed to fini lookahead2 after error occurred");
2003  }
2004  } else {
2005  ret = rcl_lexer_lookahead2_fini(&lex_lookahead);
2006  }
2007  return ret;
2008 }
2009 
2010 rcl_ret_t
2011 _rcl_parse_param_file(
2012  const char * arg,
2013  rcl_allocator_t allocator,
2014  rcl_params_t * params,
2015  char ** param_file)
2016 {
2017  RCL_CHECK_ARGUMENT_FOR_NULL(arg, RCL_RET_INVALID_ARGUMENT);
2018  RCL_CHECK_ARGUMENT_FOR_NULL(params, RCL_RET_INVALID_ARGUMENT);
2019  RCL_CHECK_ARGUMENT_FOR_NULL(param_file, RCL_RET_INVALID_ARGUMENT);
2020  *param_file = rcutils_strdup(arg, allocator);
2021  if (NULL == *param_file) {
2022  RCL_SET_ERROR_MSG("Failed to allocate memory for parameters file path");
2023  return RCL_RET_BAD_ALLOC;
2024  }
2025  if (!rcl_parse_yaml_file(*param_file, params)) {
2026  allocator.deallocate(*param_file, allocator.state);
2027  *param_file = NULL;
2028  // Error message already set.
2029  return RCL_RET_ERROR;
2030  }
2031  return RCL_RET_OK;
2032 }
2033 
2034 rcl_ret_t
2035 _rcl_parse_external_log_file_name(
2036  const char * arg,
2037  rcl_allocator_t allocator,
2038  char ** log_file_name_prefix)
2039 {
2040  RCL_CHECK_ARGUMENT_FOR_NULL(arg, RCL_RET_INVALID_ARGUMENT);
2041  RCL_CHECK_ARGUMENT_FOR_NULL(log_file_name_prefix, RCL_RET_INVALID_ARGUMENT);
2042 
2043  *log_file_name_prefix = rcutils_strdup(arg, allocator);
2044  if (NULL == *log_file_name_prefix) {
2045  RCL_SET_ERROR_MSG("Failed to allocate memory for external log file name prefix");
2046  return RCL_RET_BAD_ALLOC;
2047  }
2048  return RCL_RET_OK;
2049 }
2050 
2051 rcl_ret_t
2052 _rcl_parse_external_log_config_file(
2053  const char * arg,
2054  rcl_allocator_t allocator,
2055  char ** log_config_file)
2056 {
2057  RCL_CHECK_ARGUMENT_FOR_NULL(arg, RCL_RET_INVALID_ARGUMENT);
2058  RCL_CHECK_ARGUMENT_FOR_NULL(log_config_file, RCL_RET_INVALID_ARGUMENT);
2059 
2060  *log_config_file = rcutils_strdup(arg, allocator);
2061  // TODO(hidmic): add file checks
2062  if (NULL == *log_config_file) {
2063  RCL_SET_ERROR_MSG("Failed to allocate memory for external log config file");
2064  return RCL_RET_BAD_ALLOC;
2065  }
2066  return RCL_RET_OK;
2067 }
2068 
2069 rcl_ret_t
2070 _rcl_parse_enclave(
2071  const char * arg,
2072  rcl_allocator_t allocator,
2073  char ** enclave)
2074 {
2075  RCL_CHECK_ARGUMENT_FOR_NULL(arg, RCL_RET_INVALID_ARGUMENT);
2076  RCL_CHECK_ARGUMENT_FOR_NULL(enclave, RCL_RET_INVALID_ARGUMENT);
2077 
2078  *enclave = rcutils_strdup(arg, allocator);
2079  if (NULL == *enclave) {
2080  RCL_SET_ERROR_MSG("Failed to allocate memory for enclave name");
2081  return RCL_RET_BAD_ALLOC;
2082  }
2083  return RCL_RET_OK;
2084 }
2085 
2086 rcl_ret_t
2087 _rcl_parse_disabling_flag(
2088  const char * arg,
2089  const char * suffix,
2090  bool * disable)
2091 {
2092  RCL_CHECK_ARGUMENT_FOR_NULL(arg, RCL_RET_INVALID_ARGUMENT);
2093  RCL_CHECK_ARGUMENT_FOR_NULL(suffix, RCL_RET_INVALID_ARGUMENT);
2094  RCL_CHECK_ARGUMENT_FOR_NULL(disable, RCL_RET_INVALID_ARGUMENT);
2095 
2096  const size_t enable_prefix_len = strlen(RCL_ENABLE_FLAG_PREFIX);
2097  if (
2098  strncmp(RCL_ENABLE_FLAG_PREFIX, arg, enable_prefix_len) == 0 &&
2099  strcmp(suffix, arg + enable_prefix_len) == 0)
2100  {
2101  *disable = false;
2102  return RCL_RET_OK;
2103  }
2104 
2105  const size_t disable_prefix_len = strlen(RCL_DISABLE_FLAG_PREFIX);
2106  if (
2107  strncmp(RCL_DISABLE_FLAG_PREFIX, arg, disable_prefix_len) == 0 &&
2108  strcmp(suffix, arg + disable_prefix_len) == 0)
2109  {
2110  *disable = true;
2111  return RCL_RET_OK;
2112  }
2113 
2114  RCL_SET_ERROR_MSG_WITH_FORMAT_STRING(
2115  "Argument is not a %s%s nor a %s%s flag.",
2116  RCL_ENABLE_FLAG_PREFIX, suffix,
2117  RCL_DISABLE_FLAG_PREFIX, suffix);
2118  return RCL_RET_ERROR;
2119 }
2120 
2121 rcl_ret_t
2122 _rcl_allocate_initialized_arguments_impl(rcl_arguments_t * args, rcl_allocator_t * allocator)
2123 {
2124  args->impl = allocator->allocate(sizeof(rcl_arguments_impl_t), allocator->state);
2125  if (NULL == args->impl) {
2126  return RCL_RET_BAD_ALLOC;
2127  }
2128 
2129  rcl_arguments_impl_t * args_impl = args->impl;
2130  args_impl->num_remap_rules = 0;
2131  args_impl->remap_rules = NULL;
2133  args_impl->external_log_file_name_prefix = NULL;
2134  args_impl->external_log_config_file = NULL;
2135  args_impl->unparsed_args = NULL;
2136  args_impl->num_unparsed_args = 0;
2137  args_impl->unparsed_ros_args = NULL;
2138  args_impl->num_unparsed_ros_args = 0;
2139  args_impl->parameter_overrides = NULL;
2140  args_impl->parameter_files = NULL;
2141  args_impl->num_param_files_args = 0;
2142  args_impl->log_stdout_disabled = false;
2143  args_impl->log_rosout_disabled = false;
2144  args_impl->log_ext_lib_disabled = false;
2145  args_impl->enclave = NULL;
2146  args_impl->allocator = *allocator;
2147 
2148  return RCL_RET_OK;
2149 }
2150 
#define RCL_CHECK_ALLOCATOR_WITH_MSG(allocator, msg, fail_statement)
Check that the given allocator is initialized, or fail with a message.
Definition: allocator.h:56
rcutils_allocator_t rcl_allocator_t
Encapsulation of an allocator.
Definition: allocator.h:31
RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t rcl_arguments_get_unparsed_ros(const rcl_arguments_t *args, rcl_allocator_t allocator, int **output_unparsed_ros_indices)
Return a list of indices to unknown ROS specific arguments that were left unparsed.
#define RCL_ROS_ARGS_EXPLICIT_END_TOKEN
The token that delineates the explicit end of ROS arguments.
Definition: arguments.h:45
RCL_PUBLIC RCL_WARN_UNUSED int rcl_arguments_get_count_unparsed(const rcl_arguments_t *args)
Return the number of arguments that were not ROS specific arguments.
#define RCL_LOG_LEVEL_FLAG
The ROS flag that precedes the ROS logging level to set.
Definition: arguments.h:69
#define RCL_LOG_ROSOUT_FLAG_SUFFIX
Definition: arguments.h:83
RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t rcl_arguments_get_param_files(const rcl_arguments_t *arguments, rcl_allocator_t allocator, char ***parameter_files)
Return a list of yaml parameter file paths specified on the command line.
#define RCL_EXTERNAL_LOG_FILE_NAME_PREFIX
The ROS log file name prefix to configure external logging.
Definition: arguments.h:72
RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t rcl_arguments_copy(const rcl_arguments_t *args, rcl_arguments_t *args_out)
Copy one arguments structure into another.
#define RCL_PARAM_FLAG
The ROS flag that precedes the setting of a ROS parameter.
Definition: arguments.h:48
RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t rcl_arguments_get_param_overrides(const rcl_arguments_t *arguments, rcl_params_t **parameter_overrides)
Return all parameter overrides parsed from the command line.
RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t rcl_arguments_get_log_levels(const rcl_arguments_t *arguments, rcl_log_levels_t *log_levels)
Return log levels parsed from the command line.
#define RCL_ROS_ARGS_FLAG
The command-line flag that delineates the start of ROS arguments.
Definition: arguments.h:42
#define RCL_LOG_EXT_LIB_FLAG_SUFFIX
Definition: arguments.h:87
#define RCL_SHORT_PARAM_FLAG
The short version of the ROS flag that precedes the setting of a ROS parameter.
Definition: arguments.h:51
#define RCL_ENCLAVE_FLAG
The ROS flag that precedes the name of a ROS security enclave.
Definition: arguments.h:63
#define RCL_LOG_STDOUT_FLAG_SUFFIX
Definition: arguments.h:79
RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t rcl_parse_arguments(int argc, const char *const *argv, rcl_allocator_t allocator, rcl_arguments_t *args_output)
Parse command line arguments into a structure usable by code.
#define RCL_REMAP_FLAG
The ROS flag that precedes a ROS remapping rule.
Definition: arguments.h:57
#define RCL_EXTERNAL_LOG_CONFIG_FLAG
The ROS flag that precedes the name of a configuration file to configure logging.
Definition: arguments.h:75
#define RCL_SHORT_REMAP_FLAG
The short version of the ROS flag that precedes a ROS remapping rule.
Definition: arguments.h:60
#define RCL_SHORT_ENCLAVE_FLAG
The short version of the ROS flag that precedes the name of a ROS security enclave.
Definition: arguments.h:66
RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t rcl_arguments_fini(rcl_arguments_t *args)
Reclaim resources held inside rcl_arguments_t structure.
RCL_PUBLIC RCL_WARN_UNUSED int rcl_arguments_get_param_files_count(const rcl_arguments_t *args)
Return the number of parameter yaml files given in the arguments.
RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t rcl_arguments_get_unparsed(const rcl_arguments_t *args, rcl_allocator_t allocator, int **output_unparsed_indices)
Return a list of indices to non ROS specific arguments.
RCL_PUBLIC RCL_WARN_UNUSED int rcl_arguments_get_count_unparsed_ros(const rcl_arguments_t *args)
Return the number of ROS specific arguments that were not successfully parsed.
#define RCL_PARAM_FILE_FLAG
The ROS flag that precedes a path to a file containing ROS parameters.
Definition: arguments.h:54
RCL_PUBLIC RCL_WARN_UNUSED rcl_arguments_t rcl_get_zero_initialized_arguments(void)
Return a rcl_arguments_t struct with members initialized to NULL.
RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t rcl_remove_ros_arguments(const char *const *argv, const rcl_arguments_t *args, rcl_allocator_t allocator, int *nonros_argc, const char ***nonros_argv)
Return a list of arguments with ROS-specific arguments removed.
@ RCL_LEXEME_WILD_ONE
Definition: lexer.h:75
@ RCL_LEXEME_NS
__ns
Definition: lexer.h:49
@ RCL_LEXEME_TOKEN
a name between slashes, must match (([a-zA-Z](_)?)|_)([0-9a-zA-Z](_)?)*
Definition: lexer.h:71
@ RCL_LEXEME_EOF
Indicates end of input has been reached.
Definition: lexer.h:37
@ RCL_LEXEME_URL_TOPIC
rostopic://
Definition: lexer.h:43
@ RCL_LEXEME_BR2
\2
Definition: lexer.h:55
@ RCL_LEXEME_BR8
\8
Definition: lexer.h:67
@ RCL_LEXEME_BR4
\4
Definition: lexer.h:59
@ RCL_LEXEME_BR9
\9
Definition: lexer.h:69
@ RCL_LEXEME_URL_SERVICE
rosservice://
Definition: lexer.h:41
@ RCL_LEXEME_BR1
\1
Definition: lexer.h:53
@ RCL_LEXEME_BR6
\6
Definition: lexer.h:63
@ RCL_LEXEME_TILDE_SLASH
~/
Definition: lexer.h:39
@ RCL_LEXEME_FORWARD_SLASH
/
Definition: lexer.h:73
@ RCL_LEXEME_SEPARATOR
:=
Definition: lexer.h:51
@ RCL_LEXEME_BR3
\3
Definition: lexer.h:57
@ RCL_LEXEME_BR5
\5
Definition: lexer.h:61
@ RCL_LEXEME_BR7
\7
Definition: lexer.h:65
@ RCL_LEXEME_NODE
__node or __name
Definition: lexer.h:47
@ RCL_LEXEME_DOT
.
Definition: lexer.h:81
@ RCL_LEXEME_WILD_MULTI
**
Definition: lexer.h:77
@ RCL_LEXEME_COLON
:
Definition: lexer.h:45
enum rcl_lexeme_e rcl_lexeme_t
Type of lexeme found by lexical analysis.
RCL_PUBLIC RCL_WARN_UNUSED rcl_lexer_lookahead2_t rcl_get_zero_initialized_lexer_lookahead2(void)
Get a zero initialized rcl_lexer_lookahead2_t instance.
RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t rcl_lexer_lookahead2_fini(rcl_lexer_lookahead2_t *buffer)
Finalize an instance of an rcl_lexer_lookahead2_t structure.
RCL_PUBLIC RCL_WARN_UNUSED const char * rcl_lexer_lookahead2_get_text(const rcl_lexer_lookahead2_t *buffer)
Get the text at the point where it is currently being analyzed.
RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t rcl_lexer_lookahead2_peek2(rcl_lexer_lookahead2_t *buffer, rcl_lexeme_t *next_type1, rcl_lexeme_t *next_type2)
Look ahead at the next two lexemes in the string.
RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t rcl_lexer_lookahead2_accept(rcl_lexer_lookahead2_t *buffer, const char **lexeme_text, size_t *lexeme_text_length)
Accept a lexeme and advance analysis.
RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t rcl_lexer_lookahead2_expect(rcl_lexer_lookahead2_t *buffer, rcl_lexeme_t type, const char **lexeme_text, size_t *lexeme_text_length)
Require the next lexeme to be a certain type and advance analysis.
RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t rcl_lexer_lookahead2_peek(rcl_lexer_lookahead2_t *buffer, rcl_lexeme_t *next_type)
Look ahead at the next lexeme in the string.
RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t rcl_lexer_lookahead2_init(rcl_lexer_lookahead2_t *buffer, const char *text, rcl_allocator_t allocator)
Initialize an rcl_lexer_lookahead2_t instance.
RCL_PUBLIC rcl_ret_t rcl_log_levels_fini(rcl_log_levels_t *log_levels)
Reclaim resources held inside rcl_log_levels_t structure.
Definition: log_level.c:108
enum RCUTILS_LOG_SEVERITY rcl_log_severity_t
typedef for RCUTILS_LOG_SEVERITY;
Definition: log_level.h:33
RCL_PUBLIC rcl_ret_t rcl_log_levels_add_logger_setting(rcl_log_levels_t *log_levels, const char *logger_name, rcl_log_severity_t log_level)
Add logger setting with a name and a level.
Definition: log_level.c:151
RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t rcl_log_levels_init(rcl_log_levels_t *log_levels, const rcl_allocator_t *allocator, size_t logger_count)
Initialize a log levels structure.
Definition: log_level.c:42
RCL_PUBLIC rcl_ret_t rcl_log_levels_shrink_to_size(rcl_log_levels_t *log_levels)
Shrink log levels structure.
Definition: log_level.c:127
RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t rcl_log_levels_copy(const rcl_log_levels_t *src, rcl_log_levels_t *dst)
Copy one log levels structure into another.
Definition: log_level.c:70
RCL_PUBLIC RCL_WARN_UNUSED rcl_log_levels_t rcl_get_zero_initialized_log_levels(void)
Return a rcl_log_levels_t struct with members initialized to zero value.
Definition: log_level.c:29
RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t rcl_remap_fini(rcl_remap_t *remap)
Reclaim resources held inside rcl_remap_t structure.
Definition: remap.c:341
RCL_PUBLIC RCL_WARN_UNUSED rcl_remap_t rcl_get_zero_initialized_remap(void)
Return a rcl_remap_t struct with members initialized to NULL.
Definition: remap.c:40
RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t rcl_remap_copy(const rcl_remap_t *rule, rcl_remap_t *rule_out)
Copy one remap structure into another.
Definition: remap.c:48
char * external_log_config_file
A file used to configure the external logging library.
rcl_log_levels_t log_levels
Log levels parsed from arguments.
rcl_params_t * parameter_overrides
Parameter override rules parsed from arguments.
int num_unparsed_args
Length of unparsed_args.
int num_param_files_args
Length of parameter_files.
bool log_rosout_disabled
A boolean value indicating if the rosout topic handler should be used for log output.
bool log_stdout_disabled
A boolean value indicating if the standard out handler should be used for log output.
rcl_allocator_t allocator
Allocator used to allocate objects in this struct.
int * unparsed_args
Array of indices to non-ROS arguments.
int * unparsed_ros_args
Array of indices to unknown ROS specific arguments.
char * enclave
Enclave to be used.
bool log_ext_lib_disabled
A boolean value indicating if the external lib handler should be used for log output.
rcl_remap_t * remap_rules
Array of rules for name remapping.
int num_remap_rules
Length of remap_rules.
int num_unparsed_ros_args
Length of unparsed_ros_args.
char * external_log_file_name_prefix
A prefix used to external log file name.
char ** parameter_files
Array of yaml parameter file paths.
Hold output of parsing command line arguments.
Definition: arguments.h:36
rcl_arguments_impl_t * impl
Private implementation pointer.
Definition: arguments.h:38
Track lexical analysis and allow looking ahead 2 lexemes.
Hold default logger level and other logger setting.
Definition: log_level.h:46
rcl_allocator_t allocator
Allocator used to allocate objects in this struct.
Definition: log_level.h:56
rcl_logger_setting_t * logger_settings
Array of logger setting.
Definition: log_level.h:50
rcl_log_severity_t default_logger_level
Minimum default logger level severity.
Definition: log_level.h:48
char * replacement
Replacement portion of a rule.
Definition: remap_impl.h:49
char * node_name
A node name that this rule is limited to, or NULL if it applies to any node.
Definition: remap_impl.h:45
rcl_allocator_t allocator
Allocator used to allocate objects in this struct.
Definition: remap_impl.h:52
char * match
Match portion of a rule, or NULL if node name or namespace replacement.
Definition: remap_impl.h:47
rcl_remap_type_t type
Bitmask indicating what type of rule this is.
Definition: remap_impl.h:43
Hold remapping rules.
Definition: remap.h:35
rcl_remap_impl_t * impl
Private implementation pointer.
Definition: remap.h:37
#define RCL_RET_INVALID_LOG_LEVEL_RULE
Argument is not a valid log level rule.
Definition: types.h:116
#define RCL_RET_INVALID_PARAM_RULE
Argument is not a valid parameter rule.
Definition: types.h:114
#define RCL_RET_WRONG_LEXEME
Expected one type of lexeme but got another.
Definition: types.h:110
#define RCL_RET_INVALID_ROS_ARGS
Found invalid ros argument while parsing.
Definition: types.h:112
#define RCL_RET_INVALID_REMAP_RULE
Argument is not a valid remap rule.
Definition: types.h:108
#define RCL_RET_OK
Success return code.
Definition: types.h:28
#define RCL_RET_BAD_ALLOC
Failed to allocate memory return code.
Definition: types.h:34
#define RCL_RET_INVALID_ARGUMENT
Invalid argument return code.
Definition: types.h:36
#define RCL_RET_ERROR
Unspecified error return code.
Definition: types.h:30
rmw_ret_t rcl_ret_t
The type that holds an rcl return code.
Definition: types.h:25