ntsimulator/ntsim-ng/utils/type_utils.c

   1 /*************************************************************************
   2 *
   3 * Copyright 2020 highstreet technologies GmbH and others
   4 *
   5 * Licensed under the Apache License, Version 2.0 (the "License");
   6 * you may not use this file except in compliance with the License.
   7 * You may obtain a copy of the License at
   8 *
   9 *     http://www.apache.org/licenses/LICENSE-2.0
  10 *
  11 * Unless required by applicable law or agreed to in writing, software
  12 * distributed under the License is distributed on an "AS IS" BASIS,
  13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 * See the License for the specific language governing permissions and
  15 * limitations under the License.
  16 ***************************************************************************/
  17
  18 #define _GNU_SOURCE
  19
  20 #include "type_utils.h"
  21 #include "log_utils.h"
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <assert.h>
  25
  26 const char* typeutils_yang_type_to_str(const LY_DATA_TYPE type_base) {
  27     switch(type_base) {
  28         case LY_TYPE_DER:
  29             return "LY_TYPE_DER";
  30             break;
  31
  32         case LY_TYPE_BINARY:
  33             return "LY_TYPE_BINARY";
  34             break;
  35
  36         case LY_TYPE_BITS:
  37             return "LY_TYPE_BITS";
  38             break;
  39
  40         case LY_TYPE_BOOL:
  41             return "LY_TYPE_BOOL";
  42             break;
  43
  44         case LY_TYPE_DEC64:
  45             return "LY_TYPE_DEC64";
  46             break;
  47
  48         case LY_TYPE_EMPTY:
  49             return "LY_TYPE_EMPTY";
  50             break;
  51
  52         case LY_TYPE_ENUM:
  53             return "LY_TYPE_ENUM";
  54             break;
  55
  56         case LY_TYPE_IDENT:
  57             return "LY_TYPE_IDENT";
  58             break;
  59
  60         case LY_TYPE_INST:
  61             return "LY_TYPE_INST";
  62             break;
  63
  64         case LY_TYPE_LEAFREF:
  65             return "LY_TYPE_LEAFREF";
  66             break;
  67
  68         case LY_TYPE_STRING:
  69             return "LY_TYPE_STRING";
  70             break;
  71
  72         case LY_TYPE_UNION:
  73             return "LY_TYPE_UNION";
  74             break;
  75
  76         case LY_TYPE_INT8:
  77             return "LY_TYPE_INT8";
  78             break;
  79
  80         case LY_TYPE_UINT8:
  81             return "LY_TYPE_UINT8";
  82             break;
  83
  84         case LY_TYPE_INT16:
  85             return "LY_TYPE_INT16";
  86             break;
  87
  88         case LY_TYPE_UINT16:
  89             return "LY_TYPE_UINT16";
  90             break;
  91
  92         case LY_TYPE_INT32:
  93             return "LY_TYPE_INT32";
  94             break;
  95
  96         case LY_TYPE_UINT32:
  97             return "LY_TYPE_UINT32";
  98             break;
  99
 100         case LY_TYPE_INT64:
 101             return "LY_TYPE_INT64";
 102             break;
 103
 104         case LY_TYPE_UINT64:
 105             return "LY_TYPE_UINT64";
 106             break;
 107
 108         case LY_TYPE_UNKNOWN:
 109             return "LY_TYPE_UNKNOWN";
 110             break;
 111     }
 112
 113     return "(unknown LY_TYPE)";
 114 }
 115
 116 const char* typeutils_yang_nodetype_to_str(const LYS_NODE nodetype) {
 117     switch(nodetype) {
 118         case LYS_UNKNOWN:
 119             return "LYS_UNKNOWN";
 120             break;
 121
 122         case LYS_CONTAINER:
 123             return "LYS_CONTAINER";
 124             break;
 125
 126         case LYS_CHOICE:
 127             return "LYS_CHOICE";
 128             break;
 129
 130         case LYS_LEAF:
 131             return "LYS_LEAF";
 132             break;
 133
 134         case LYS_LEAFLIST:
 135             return "LYS_LEAFLIST";
 136             break;
 137
 138         case LYS_LIST:
 139             return "LYS_LIST";
 140             break;
 141
 142         case LYS_ANYXML:
 143             return "LYS_ANYXML";
 144             break;
 145
 146         case LYS_CASE:
 147             return "LYS_CASE";
 148             break;
 149
 150         case LYS_NOTIF:
 151             return "LYS_NOTIF";
 152             break;
 153
 154         case LYS_RPC:
 155             return "LYS_RPC";
 156             break;
 157
 158         case LYS_INPUT:
 159             return "LYS_INPUT";
 160             break;
 161
 162         case LYS_OUTPUT:
 163             return "LYS_OUTPUT";
 164             break;
 165
 166         case LYS_GROUPING:
 167             return "LYS_GROUPING";
 168             break;
 169
 170         case LYS_USES:
 171             return "LYS_USES";
 172             break;
 173
 174         case LYS_AUGMENT:
 175             return "LYS_AUGMENT";
 176             break;
 177
 178         case LYS_ACTION:
 179             return "LYS_ACTION";
 180             break;
 181
 182         case LYS_ANYDATA:
 183             return "LYS_ANYDATA";
 184             break;
 185
 186         case LYS_EXT:
 187             return "LYS_EXT";
 188             break;
 189
 190         default:
 191             return "(unknown node type)";
 192             break;
 193
 194     }
 195 }
 196
 197 char* typeutils_type_to_str(const struct lys_type *type) {
 198     assert(type);
 199
 200     struct lys_ident *ref = 0;
 201     char *ret = 0;
 202
 203     switch(type->base) {
 204         case LY_TYPE_ENUM:
 205             if(type->info.enums.count) {
 206                 ret = (char*)realloc(ret, sizeof(char) * 1024 * 1024);
 207                 if(!ret) {
 208                     log_error("bad malloc\n");
 209                     return 0;
 210                 }
 211
 212                 sprintf(ret, "enum(%d):", type->info.enums.count);
 213                 for(int i = 0; i < type->info.enums.count; i++) {
 214                     char *add = 0;
 215                     asprintf(&add, " %s(%d)", type->info.enums.enm[i].name, type->info.enums.enm[i].value);
 216                     strcat(ret, add);
 217                     free(add);
 218                 }
 219
 220                 ret = (char*)realloc(ret, sizeof(char) * (strlen(ret) + 1));    //resize back
 221             }
 222             else {
 223                 if(type->der) {
 224                     char *add = typeutils_type_to_str(&type->der->type);
 225                     if(type->der->module) {
 226                         asprintf(&ret, "%s:%s >>> %s", type->der->module->name, type->der->name, add);
 227                     }
 228                     else  {
 229                         asprintf(&ret, "%s >>> %s", type->der->name, add);
 230                     }
 231                     free(add);
 232                 }
 233             }
 234             break;
 235
 236         case LY_TYPE_IDENT:
 237             if(type->info.ident.count) {
 238                 ref = type->info.ident.ref[0];
 239                 if(ref) {
 240                     if(ref->module) {
 241                         asprintf(&ret, "ident: %s:%s", ref->module->name, ref->name);
 242                     }
 243                     else  {
 244                         asprintf(&ret, "ident: %s", ref->name);
 245                     }
 246                 }
 247             }
 248             else if(type->der->module) {
 249                 return typeutils_type_to_str(&type->der->type);
 250             }
 251             break;
 252
 253         case LY_TYPE_UNION:
 254             if(type->der) {
 255                 if(type->der->module) {
 256                     asprintf(&ret, "union: %s:%s", type->der->module->name, type->der->name);
 257                 }
 258                 else  {
 259                     asprintf(&ret, "union: %s", type->der->name);
 260                 }
 261             }
 262             break;
 263
 264         case LY_TYPE_STRING:
 265             if(type->info.str.length) {
 266                 asprintf(&ret, "%s:%s", type->der->name, type->info.str.length->expr);
 267             }
 268             else {
 269                 asprintf(&ret, "%s", type->der->name);
 270             }
 271             break;
 272
 273         default:
 274             if(type->der) {
 275                 if(type->der->module) {
 276                     asprintf(&ret, "%s:%s", type->der->module->name, type->der->name);
 277                 }
 278                 else  {
 279                     asprintf(&ret, "%s", type->der->name);
 280                 }
 281             }
 282             break;
 283     }
 284
 285     return ret;
 286 }