Line data    Source code

       1             : /* SPDX-License-Identifier: LGPL-2.1+ */
       2             : 
       3             : #include <errno.h>
       4             : 
       5             : #include "sd-bus.h"
       6             : 
       7             : #include "bus-type.h"
       8             : 
       9           5 : bool bus_type_is_valid(char c) {
      10             :         static const char valid[] = {
      11             :                 SD_BUS_TYPE_BYTE,
      12             :                 SD_BUS_TYPE_BOOLEAN,
      13             :                 SD_BUS_TYPE_INT16,
      14             :                 SD_BUS_TYPE_UINT16,
      15             :                 SD_BUS_TYPE_INT32,
      16             :                 SD_BUS_TYPE_UINT32,
      17             :                 SD_BUS_TYPE_INT64,
      18             :                 SD_BUS_TYPE_UINT64,
      19             :                 SD_BUS_TYPE_DOUBLE,
      20             :                 SD_BUS_TYPE_STRING,
      21             :                 SD_BUS_TYPE_OBJECT_PATH,
      22             :                 SD_BUS_TYPE_SIGNATURE,
      23             :                 SD_BUS_TYPE_ARRAY,
      24             :                 SD_BUS_TYPE_VARIANT,
      25             :                 SD_BUS_TYPE_STRUCT,
      26             :                 SD_BUS_TYPE_DICT_ENTRY,
      27             :                 SD_BUS_TYPE_UNIX_FD
      28             :         };
      29             : 
      30           5 :         return !!memchr(valid, c, sizeof(valid));
      31             : }
      32             : 
      33        7440 : bool bus_type_is_basic(char c) {
      34             :         static const char valid[] = {
      35             :                 SD_BUS_TYPE_BYTE,
      36             :                 SD_BUS_TYPE_BOOLEAN,
      37             :                 SD_BUS_TYPE_INT16,
      38             :                 SD_BUS_TYPE_UINT16,
      39             :                 SD_BUS_TYPE_INT32,
      40             :                 SD_BUS_TYPE_UINT32,
      41             :                 SD_BUS_TYPE_INT64,
      42             :                 SD_BUS_TYPE_UINT64,
      43             :                 SD_BUS_TYPE_DOUBLE,
      44             :                 SD_BUS_TYPE_STRING,
      45             :                 SD_BUS_TYPE_OBJECT_PATH,
      46             :                 SD_BUS_TYPE_SIGNATURE,
      47             :                 SD_BUS_TYPE_UNIX_FD
      48             :         };
      49             : 
      50        7440 :         return !!memchr(valid, c, sizeof(valid));
      51             : }
      52             : 
      53           6 : bool bus_type_is_trivial(char c) {
      54             :         static const char valid[] = {
      55             :                 SD_BUS_TYPE_BYTE,
      56             :                 SD_BUS_TYPE_BOOLEAN,
      57             :                 SD_BUS_TYPE_INT16,
      58             :                 SD_BUS_TYPE_UINT16,
      59             :                 SD_BUS_TYPE_INT32,
      60             :                 SD_BUS_TYPE_UINT32,
      61             :                 SD_BUS_TYPE_INT64,
      62             :                 SD_BUS_TYPE_UINT64,
      63             :                 SD_BUS_TYPE_DOUBLE
      64             :         };
      65             : 
      66           6 :         return !!memchr(valid, c, sizeof(valid));
      67             : }
      68             : 
      69         625 : bool bus_type_is_container(char c) {
      70             :         static const char valid[] = {
      71             :                 SD_BUS_TYPE_ARRAY,
      72             :                 SD_BUS_TYPE_VARIANT,
      73             :                 SD_BUS_TYPE_STRUCT,
      74             :                 SD_BUS_TYPE_DICT_ENTRY
      75             :         };
      76             : 
      77         625 :         return !!memchr(valid, c, sizeof(valid));
      78             : }
      79             : 
      80         318 : int bus_type_get_alignment(char c) {
      81             : 
      82         318 :         switch (c) {
      83          70 :         case SD_BUS_TYPE_BYTE:
      84             :         case SD_BUS_TYPE_SIGNATURE:
      85             :         case SD_BUS_TYPE_VARIANT:
      86          70 :                 return 1;
      87             : 
      88           0 :         case SD_BUS_TYPE_INT16:
      89             :         case SD_BUS_TYPE_UINT16:
      90           0 :                 return 2;
      91             : 
      92         117 :         case SD_BUS_TYPE_BOOLEAN:
      93             :         case SD_BUS_TYPE_INT32:
      94             :         case SD_BUS_TYPE_UINT32:
      95             :         case SD_BUS_TYPE_STRING:
      96             :         case SD_BUS_TYPE_OBJECT_PATH:
      97             :         case SD_BUS_TYPE_ARRAY:
      98             :         case SD_BUS_TYPE_UNIX_FD:
      99         117 :                 return 4;
     100             : 
     101         131 :         case SD_BUS_TYPE_INT64:
     102             :         case SD_BUS_TYPE_UINT64:
     103             :         case SD_BUS_TYPE_DOUBLE:
     104             :         case SD_BUS_TYPE_STRUCT:
     105             :         case SD_BUS_TYPE_STRUCT_BEGIN:
     106             :         case SD_BUS_TYPE_DICT_ENTRY:
     107             :         case SD_BUS_TYPE_DICT_ENTRY_BEGIN:
     108         131 :                 return 8;
     109             :         }
     110             : 
     111           0 :         return -EINVAL;
     112             : }
     113             : 
     114         164 : int bus_type_get_size(char c) {
     115             : 
     116         164 :         switch (c) {
     117          70 :         case SD_BUS_TYPE_BYTE:
     118          70 :                 return 1;
     119             : 
     120           0 :         case SD_BUS_TYPE_INT16:
     121             :         case SD_BUS_TYPE_UINT16:
     122           0 :                 return 2;
     123             : 
     124          56 :         case SD_BUS_TYPE_BOOLEAN:
     125             :         case SD_BUS_TYPE_INT32:
     126             :         case SD_BUS_TYPE_UINT32:
     127             :         case SD_BUS_TYPE_UNIX_FD:
     128          56 :                 return 4;
     129             : 
     130          38 :         case SD_BUS_TYPE_INT64:
     131             :         case SD_BUS_TYPE_UINT64:
     132             :         case SD_BUS_TYPE_DOUBLE:
     133          38 :                 return 8;
     134             :         }
     135             : 
     136           0 :         return -EINVAL;
     137             : }