blob: b708c65135f4e2989fd95ce051241c2f650e0429 [file] [log] [blame]
Rich Lanea06d0c32013-03-25 08:52:03 -07001# Copyright 2013, Big Switch Networks, Inc.
2#
3# LoxiGen is licensed under the Eclipse Public License, version 1.0 (EPL), with
4# the following special exception:
5#
6# LOXI Exception
7#
8# As a special exception to the terms of the EPL, you may distribute libraries
9# generated by LoxiGen (LoxiGen Libraries) under the terms of your choice, provided
10# that copyright and licensing notices generated by LoxiGen are not altered or removed
11# from the LoxiGen Libraries and the notice provided below is (i) included in
12# the LoxiGen Libraries, if distributed in source code form and (ii) included in any
13# documentation for the LoxiGen Libraries, if distributed in binary form.
14#
15# Notice: "Copyright 2013, Big Switch Networks, Inc. This library was generated by the LoxiGen Compiler."
16#
17# You may not use this file except in compliance with the EPL or LOXI Exception. You may obtain
18# a copy of the EPL at:
19#
20# http://www.eclipse.org/legal/epl-v10.html
21#
22# Unless required by applicable law or agreed to in writing, software
23# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
24# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
25# EPL for the specific language governing permissions and limitations
26# under the EPL.
27
28"""
29@file code_gen.py
30Code generation functions for LOCI
31"""
32
33import sys
Andreas Wundsam76db0062013-11-15 13:34:41 -080034import c_gen.of_g_legacy as of_g
Rich Lanea06d0c32013-03-25 08:52:03 -070035import c_match
36from generic_utils import *
Andreas Wundsam542a13c2013-11-15 13:28:55 -080037from c_gen import flags, type_maps, c_type_maps
38import c_gen.loxi_utils_legacy as loxi_utils
Rich Lane92feca82013-12-10 15:57:13 -080039import loxi_globals
Rich Lanea06d0c32013-03-25 08:52:03 -070040
Andreas Wundsam542a13c2013-11-15 13:28:55 -080041import c_gen.identifiers as identifiers
Rich Lanea06d0c32013-03-25 08:52:03 -070042
Andreas Wundsam76db0062013-11-15 13:34:41 -080043# 'property' is for queues. Could be trouble
Rich Lanea06d0c32013-03-25 08:52:03 -070044
45################################################################
46#
47# Misc helper functions
48#
49################################################################
50
51def h_file_to_define(name):
52 """
53 Convert a .h file name to the define used for the header
54 """
55 h_name = name[:-2].upper()
56 h_name = "_" + h_name + "_H_"
57 return h_name
58
59def enum_name(cls):
60 """
61 Return the name used for an enum identifier for the given class
62 @param cls The class name
63 """
64 return loxi_utils.enum_name(cls)
65
Rich Lanea06d0c32013-03-25 08:52:03 -070066# TODO serialize match outside accessor?
67def accessor_return_type(a_type, m_type):
68 if loxi_utils.accessor_returns_error(a_type, m_type):
69 return "int WARN_UNUSED_RESULT"
70 else:
71 return "void"
72
73def accessor_return_success(a_type, m_type):
74 if loxi_utils.accessor_returns_error(a_type, m_type):
75 return "OF_ERROR_NONE"
76 else:
77 return ""
78
79################################################################
80#
81# Per-file generators, mapped to jump table below
82#
83################################################################
84
85def base_h_gen(out, name):
86 """
87 Generate code for base header file
88 @param out The file handle to write to
89 @param name The name of the file
90 """
91 common_top_matter(out, name)
92 base_h_content(out)
93 gen_object_enum(out)
94 out.write("""
95/****************************************************************
96 *
97 * Experimenter IDs
98 *
99 ****************************************************************/
100
101""")
102 for name, val in of_g.experimenter_name_to_id.items():
103 out.write("#define OF_EXPERIMENTER_ID_%s 0x%08x\n" %
104 (name.upper(), val))
105
106 out.write("""
107/****************************************************************
108 *
109 * OpenFlow Match version specific and generic defines
110 *
111 ****************************************************************/
112""")
113 c_match.gen_v4_match_compat(out)
114 c_match.gen_match_macros(out)
115 c_match.gen_oxm_defines(out)
116 out.write("\n#endif /* Base header file */\n")
117
118def identifiers_gen(out, filename):
119 """
120 Generate the macros for LOCI identifiers
121 @param out The file handle to write to
122 @param filename The name of the file
123 """
124 common_top_matter(out, filename)
125 out.write("""
126/**
127 * For each identifier from an OpenFlow header file, a Loxi version
128 * of the identifier is generated. For example, ofp_port_flood becomes
Andreas Wundsam53256162013-05-02 14:05:53 -0700129 * OF_PORT_DEST_FLOOD. Loxi provides the following macros related to
Rich Lanea06d0c32013-03-25 08:52:03 -0700130 * OpenFlow identifiers (using OF_IDENT_ as an example below):
131 * OF_IDENT_BY_VERSION(version) Get the value for the specific version
132 * OF_IDENT_SUPPORTED(version) Boolean: Is OF_IDENT defined for version
133 * OF_IDENT The common value across all versions if defined
134 * OF_IDENT_GENERIC A unique value across all OF identifiers
135 *
136 * For identifiers marked as flags, the following are also defined
137 * OF_IDENT_SET(flags, version)
138 * OF_IDENT_CLEAR(flags, version)
139 * OF_IDENT_TEST(flags, version)
140 *
141 * Notes:
142 *
143 * OF_IDENT_BY_VERSION(version) returns an undefined value
144 * if the passed version does not define OF_IDENT. It does not generate an
145 * error, nor record anything to the log file. If the value is the same
146 * across all defined versions, the version is ignored.
147 *
148 * OF_IDENT is only defined if the value is the same across all
149 * target LOXI versions FOR WHICH IT IS DEFINED. No error checking is
150 * done. This allows code to be written without requiring the version
151 * to be known or referenced when it doesn't matter. It does mean
152 * that when porting to a new version of OpenFlow, compile errors may
153 * occur. However, this is an indication that the existing code must
154 * be updated to account for a change in the semantics with the newly
155 * supported OpenFlow version.
156 *
157 * @fixme Currently we do not handle multi-bit flags or field values; for
158 * example, OF_TABLE_CONFIG_TABLE_MISS_CONTROLLER is the meaning for
159 * a zero value in the bits indicated by OF_TABLE_CONFIG_TABLE_MISS_MASK.
160 *
161 * @fixme Need to decide (or make a code gen option) on the requirement
162 * for defining OF_IDENT: Is it that all target versions define it and
163 * the agree? Or only that the versions which define it agree?
164 */
165""")
166
167 # Build value-by-version parameters and c_code
168 if len(of_g.target_version_list) > 1: # Supporting more than one version
169 vbv_params = []
170 vbv_code = ""
171 first = True
172 for version in of_g.target_version_list:
173 vbv_params.append("value_%s" % of_g.short_version_names[version])
174 if not first:
175 vbv_code += "\\\n "
176 else:
177 first = False
178 last_value = "value_%s" % of_g.short_version_names[version]
179 vbv_code += "((version) == %s) ? (%s) : " % \
180 (of_g.of_version_wire2name[version], last_value)
181 # @todo Using last value, can optimize out last ?
182 vbv_code += "(%s)" % last_value
183
184 out.write("""
185/**
186 * @brief True for the special case of all versions supported
187 */
188#define OF_IDENT_IN_ALL_VERSIONS 1 /* Indicates identifier in all versions */
189
190/**
191 * @brief General macro to map version to value where values given as params
192 *
193 * If unknown version is passed, use the latest version's value
194 */
195#define OF_VALUE_BY_VERSION(version, %s) \\
196 (%s)
197
198/**
199 * @brief Generic set a flag
200 */
201#define OF_FLAG_SET(flags, mask) (flags) = (flags) | (mask)
202
203/**
204 * @brief Generic test if a flag is set
205 */
206#define OF_FLAG_CLEAR(flags, mask) (flags) = (flags) & ~(mask)
207
208/**
209 * @brief Generic test if a flag is set
210 */
211#define OF_FLAG_TEST(flags, mask) ((flags) & (mask) ? 1 : 0)
212
213/**
214 * @brief Set a flag where the value is an enum indication of bit shift
215 */
216#define OF_FLAG_ENUM_SET(flags, e_val) OF_FLAG_SET(flags, 1 << (e_val))
217
218/**
219 * @brief Clear a flag where the value is an enum indication of bit shift
220 */
221#define OF_FLAG_ENUM_CLEAR(flags, e_val) OF_FLAG_CLEAR(flags, 1 << (e_val))
222
223/**
224 * @brief Test a flag where the value is an enum indication of bit shift
225 */
226#define OF_FLAG_ENUM_TEST(flags, e_val) OF_FLAG_TEST(flags, 1 << (e_val))
227""" % (", ".join(vbv_params), vbv_code))
228
229 # For each group of identifiers, bunch ident defns
230 count = 1
231 keys = of_g.identifiers_by_group.keys()
232 keys.sort()
233 for group in keys:
234 idents = of_g.identifiers_by_group[group]
235 idents.sort()
236 out.write("""
237/****************************************************************
Andreas Wundsam53256162013-05-02 14:05:53 -0700238 * Identifiers from %s
Rich Lanea06d0c32013-03-25 08:52:03 -0700239 *****************************************************************/
240""" % group)
241 for ident in idents:
242 info = of_g.identifiers[ident]
243
244 keys = info["values_by_version"].keys()
245 keys.sort()
246
247 out.write("""
248/*
249 * Defines for %(ident)s
250 * Original name %(ofp_name)s
251 */
252""" % dict(ident=ident, ofp_name=info["ofp_name"]))
253
254 # Generate supported versions macro
255 if len(keys) == len(of_g.target_version_list): # Defined for all
256 out.write("""\
257#define %(ident)s_SUPPORTED(version) OF_IDENT_IN_ALL_VERSIONS
258""" % dict(ident=ident))
259 else: # Undefined for some version
260 sup_list = []
261 for version in keys:
262 sup_list.append("((version) == %s)" %
263 of_g.of_version_wire2name[version])
264 out.write("""\
265#define %(ident)s_SUPPORTED(version) \\
266 (%(sup_str)s)
267""" % dict(ident=ident, sup_str=" || \\\n ".join(sup_list)))
268
269 # Generate value macro
270 if identifiers.defined_versions_agree(of_g.identifiers,
271 of_g.target_version_list,
272 ident):
273 out.write("""\
Rich Lanef3dc3962013-05-10 16:16:48 -0700274#define %(ident)s (%(value)#x)
275#define %(ident)s_BY_VERSION(version) (%(value)#x)
Rich Lanea06d0c32013-03-25 08:52:03 -0700276""" % dict(ident=ident,value=info["common_value"]))
277 else: # Values differ between versions
278 # Generate version check and value by version
279 val_list = []
280 # Order of params matters
281 for version in of_g.target_version_list:
282 if version in info["values_by_version"]:
283 value = info["values_by_version"][version]
284 else:
285 value = identifiers.UNDEFINED_IDENT_VALUE
Rich Lanef3dc3962013-05-10 16:16:48 -0700286 val_list.append("%#x" % value)
Rich Lanea06d0c32013-03-25 08:52:03 -0700287 out.write("""\
288#define %(ident)s_BY_VERSION(version) \\
289 OF_VALUE_BY_VERSION(version, %(val_str)s)
290""" % dict(ident=ident, val_str=", ".join(val_list)))
291 if flags.ident_is_flag(ident):
292 log("Treating %s as a flag" % ident)
293 out.write("""
294#define %(ident)s_SET(flags, version) \\
295 OF_FLAG_SET(flags, %(ident)s_BY_VERSION(version))
296#define %(ident)s_TEST(flags, version) \\
297 OF_FLAG_TEST(flags, %(ident)s_BY_VERSION(version))
298#define %(ident)s_CLEAR(flags, version) \\
299 OF_FLAG_CLEAR(flags, %(ident)s_BY_VERSION(version))
300""" % dict(ident=ident))
301
302 out.write("#define %(ident)s_GENERIC %(count)d\n"
303 % dict(ident=ident, count=count))
304 count += 1 # This count should probably be promoted higher
305
306 log("Generated %d identifiers" % (count - 1))
307 out.write("\n#endif /* Loci identifiers header file */\n")
308
Rich Lanea06d0c32013-03-25 08:52:03 -0700309def match_h_gen(out, name):
310 """
311 Generate code for
312 @param out The file handle to write to
313 @param name The name of the file
314 """
315 c_match.match_h_top_matter(out, name)
Rich Lanea06d0c32013-03-25 08:52:03 -0700316 c_match.gen_match_struct(out)
317 c_match.gen_match_comp(out)
Rich Lanea06d0c32013-03-25 08:52:03 -0700318 out.write("\n#endif /* Match header file */\n")
319
320def top_h_gen(out, name):
321 """
322 Generate code for
323 @param out The file handle to write to
324 @param name The name of the file
325 """
326 external_h_top_matter(out, name)
327 out.write("""
328
329typedef enum loci_log_level {
330 LOCI_LOG_LEVEL_TRACE,
331 LOCI_LOG_LEVEL_VERBOSE,
332 LOCI_LOG_LEVEL_INFO,
333 LOCI_LOG_LEVEL_WARN,
334 LOCI_LOG_LEVEL_ERROR,
335 LOCI_LOG_LEVEL_MSG
336} loci_log_level_t;
337
338/**
339 * @brief Output a log message.
340 * @param level The log level.
341 * @param fname The function name.
342 * @param file The file name.
343 * @param line The line number.
344 * @param format The message format string.
345 */
346typedef int (*loci_logger_f)(loci_log_level_t level,
347 const char *fname, const char *file, int line,
348 const char *format, ...);
349
350/*
351 * This variable should be set by the user of the library to redirect logs to
352 * their log infrastructure. The default drops all logs.
353 */
354extern loci_logger_f loci_logger;
355
356/**
357 * Map a generic object to the underlying wire buffer
358 *
359 * Treat as private
360 */
361#define OF_OBJECT_TO_MESSAGE(obj) \\
Rich Lanecdd542d2014-04-03 16:13:12 -0700362 ((of_message_t)(WBUF_BUF((obj)->wbuf)))
Rich Lanea06d0c32013-03-25 08:52:03 -0700363
364/**
365 * Macro for the fixed length part of an object
366 *
367 * @param obj The object whose extended length is being calculated
368 * @returns length in bytes of non-variable part of the object
369 */
370#define OF_OBJECT_FIXED_LENGTH(obj) \\
371 (of_object_fixed_len[(obj)->version][(obj)->object_id])
372
373/**
374 * Return the length of the object beyond its fixed length
375 *
376 * @param obj The object whose extended length is being calculated
377 * @returns length in bytes of non-variable part of the object
378 *
379 * Most variable length fields are alone at the end of a structure.
380 * Their length is a simple calculation, just the total length of
381 * the parent minus the length of the non-variable part of the
382 * parent's class type.
383 */
384
385#define OF_OBJECT_VARIABLE_LENGTH(obj) \\
386 ((obj)->length - OF_OBJECT_FIXED_LENGTH(obj))
387
Rich Lanea06d0c32013-03-25 08:52:03 -0700388extern int of_wire_buffer_of_match_get(of_object_t *obj, int offset,
389 of_match_t *match);
390extern int of_wire_buffer_of_match_set(of_object_t *obj, int offset,
391 of_match_t *match, int cur_len);
Rich Lanea06d0c32013-03-25 08:52:03 -0700392""")
393
394 # gen_base_types(out)
395
Rich Lanea06d0c32013-03-25 08:52:03 -0700396 out.write("""
397/****************************************************************
398 *
399 * Declarations of maps between on-the-wire type values and LOCI identifiers
400 *
401 ****************************************************************/
Rich Lanec0e20ff2013-12-15 23:40:31 -0800402
Rich Lanec0e20ff2013-12-15 23:40:31 -0800403int of_object_wire_init(of_object_t *obj, of_object_id_t base_object_id, int max_len);
404
405extern const int *const of_object_fixed_len[OF_VERSION_ARRAY_MAX];
Rich Lanea06d0c32013-03-25 08:52:03 -0700406""")
Rich Lanea06d0c32013-03-25 08:52:03 -0700407 c_type_maps.gen_type_data_header(out)
408 c_match.gen_declarations(out)
409 # @fixme Move debug stuff to own fn
410 out.write("""
411/**
412 * Macro to check consistency of length for top level objects
413 *
414 * If the object has no parent then its length should match the
415 * underlying wire buffer's current bytes.
416 */
417#define OF_LENGTH_CHECK_ASSERT(obj) \\
Rich Lanee57f0432014-02-19 10:31:53 -0800418 LOCI_ASSERT(((obj)->parent != NULL) || \\
Rich Lanecdd542d2014-04-03 16:13:12 -0700419 ((obj)->wbuf == NULL) || \\
420 (WBUF_CURRENT_BYTES((obj)->wbuf) == (obj)->length))
Rich Lanea06d0c32013-03-25 08:52:03 -0700421
422#define OF_DEBUG_DUMP
423#if defined(OF_DEBUG_DUMP)
424extern void dump_match(of_match_t *match);
425#endif /* OF_DEBUG_DUMP */
426""")
427
Rich Lane1f03f672014-08-05 00:10:00 -0700428 out.write("""
429static inline const char *
430of_class_name(of_object_t *obj)
431{
432 return of_object_id_str[obj->object_id];
433}
434""")
435
Rich Lanea06d0c32013-03-25 08:52:03 -0700436 out.write("\n#endif /* Top header file */\n")
437
438def match_c_gen(out, name):
439 """
440 Generate code for
441 @param out The file handle to write to
442 @param name The name of the file
443 """
444 c_match.match_c_top_matter(out, name)
445 c_match.gen_match_conversions(out)
446 c_match.gen_serialize(out)
447 c_match.gen_deserialize(out)
448
Rich Lanea06d0c32013-03-25 08:52:03 -0700449################################################################
450# Top Matter
451################################################################
452
453def common_top_matter(out, name):
454 loxi_utils.gen_c_copy_license(out)
455 out.write("""\
Rich Laned983aa52013-06-13 11:48:37 -0700456
Rich Lanea06d0c32013-03-25 08:52:03 -0700457/****************************************************************
458 * File: %s
459 *
460 * DO NOT EDIT
461 *
462 * This file is automatically generated
463 *
464 ****************************************************************/
465
466""" % name)
467
468 if name[-2:] == ".h":
469 out.write("""
470#if !defined(%(h)s)
471#define %(h)s
472
473""" % dict(h=h_file_to_define(name)))
474
475def base_h_content(out):
476 """
477 Generate base header file content
478
479 @param out The output file object
480 """
481
482 # @fixme Supported version should be generated based on input to LoxiGen
483
484 out.write("""
485/*
486 * Base OpenFlow definitions. These depend only on standard C headers
487 */
488#include <string.h>
489#include <stdint.h>
490
491/* g++ requires this to pick up PRI, etc.
492 * See http://gcc.gnu.org/ml/gcc-help/2006-10/msg00223.html
493 */
494#if !defined(__STDC_FORMAT_MACROS)
495#define __STDC_FORMAT_MACROS
496#endif
497#include <inttypes.h>
498
499#include <stdlib.h>
500#include <assert.h>
501#include <loci/loci_idents.h>
502
503/**
504 * Macro to enable debugging for LOCI.
505 *
506 * This enables debug output to stdout.
507 */
508#define OF_DEBUG_ENABLE
509
510#if defined(OF_DEBUG_ENABLE)
511#include <stdio.h> /* Currently for debugging */
512#define FIXME(str) do { \\
513 fprintf(stderr, "%s\\n", str); \\
514 exit(1); \\
515 } while (0)
516#define debug printf
517#else
518#define FIXME(str)
519#define debug(str, ...)
520#endif /* OF_DEBUG_ENABLE */
521
522/**
523 * The type of a function used by the LOCI dump/show functions to
524 * output text. Essentially the same signature as fprintf. May
525 * be called many times per invocation of e.g. of_object_show().
526 */
527typedef int (*loci_writer_f)(void *cookie, const char *fmt, ...);
528
529/**
530 * Check if a version is supported
531 */
Rich Lane2b49df62014-10-14 11:41:28 -0700532#define OF_VERSION_OKAY(v) ((v) >= OF_VERSION_1_0 && (v) <= OF_VERSION_1_4)
Rich Lanea06d0c32013-03-25 08:52:03 -0700533
534""")
535 gen_version_enum(out)
536 out.write("\n")
537
538 # for c_name in of_g.ofp_constants:
539 # val = str(of_g.ofp_constants[c_name])
540 # out.write("#define %s %s\n" % (c_name, val))
541 # out.write("\n")
542
543 out.write("""
544typedef enum of_error_codes_e {
545 OF_ERROR_NONE = 0,
546 OF_ERROR_RESOURCE = -1, /* Could not allocate space */
547 OF_ERROR_PARAM = -2, /* Bad parameter */
548 OF_ERROR_VERSION = -3, /* Version not supported */
549 OF_ERROR_RANGE = -4, /* End of list indication */
550 OF_ERROR_COMPAT = -5, /* Incompatible assignment */
551 OF_ERROR_PARSE = -6, /* Error in parsing data */
552 OF_ERROR_INIT = -7, /* Uninitialized data */
553 OF_ERROR_UNKNOWN = -8 /* Unknown error */
554} of_error_codes_t;
555
556#define OF_ERROR_STRINGS "none", \\
557 "resource", \\
558 "parameter", \\
559 "version", \\
560 "range", \\
561 "incompatible", \\
562 "parse", \\
563 "init", \\
564 "unknown"
565
Rich Laneb157b0f2013-03-27 13:55:28 -0700566extern const char *const of_error_strings[];
Rich Lanea06d0c32013-03-25 08:52:03 -0700567
Rich Lanea8b54632014-02-19 11:17:47 -0800568#ifdef __GNUC__
569#define LOCI_NORETURN_ATTR __attribute__((__noreturn__))
570#else
571#define LOCI_NORETURN_ATTR
572#endif
573
574extern void loci_assert_fail(
575 const char *cond,
576 const char *file,
577 unsigned int line) LOCI_NORETURN_ATTR;
578
Rich Lane53757732013-02-23 17:00:10 -0800579#ifndef NDEBUG
Rich Lanea8b54632014-02-19 11:17:47 -0800580#define LOCI_ASSERT(val) ((val) ? (void)0 : loci_assert_fail(#val, __FILE__, __LINE__))
Rich Lane53757732013-02-23 17:00:10 -0800581#else
Rich Lanee57f0432014-02-19 10:31:53 -0800582#define LOCI_ASSERT(val)
Rich Lane53757732013-02-23 17:00:10 -0800583#endif
Rich Lanea06d0c32013-03-25 08:52:03 -0700584
585/*
586 * Some LOCI object accessors can fail, and it's easy to forget to check.
587 * On certain compilers we can trigger a warning if the error code
588 * is ignored.
589 */
590#ifndef DISABLE_WARN_UNUSED_RESULT
591#ifdef __GNUC__
592#define WARN_UNUSED_RESULT __attribute__ ((warn_unused_result))
593#else
594#define WARN_UNUSED_RESULT
595#endif
596#else
597#define WARN_UNUSED_RESULT
598#endif
599
600typedef union of_generic_u of_generic_t;
601typedef struct of_object_s of_object_t;
602
603/* Define ipv4 address as uint32 */
604typedef uint32_t of_ipv4_t;
605
606/* Table ID is the OF standard uint8 */
607typedef uint8_t of_table_id_t;
608
609#define OF_MAC_ADDR_BYTES 6
610typedef struct of_mac_addr_s {
611 uint8_t addr[OF_MAC_ADDR_BYTES];
612} of_mac_addr_t;
613
614#define OF_IPV6_BYTES 16
615typedef struct of_ipv6_s {
616 uint8_t addr[OF_IPV6_BYTES];
617} of_ipv6_t;
618
619extern const of_mac_addr_t of_mac_addr_all_ones;
620extern const of_mac_addr_t of_mac_addr_all_zeros;
621
622extern const of_ipv6_t of_ipv6_all_ones;
623extern const of_ipv6_t of_ipv6_all_zeros;
624
625/**
626 * Generic zero and all-ones values of size 16 bytes.
627 *
628 * IPv6 is longest data type we worry about for comparisons
629 */
630#define of_all_zero_value of_ipv6_all_zeros
631#define of_all_ones_value of_ipv6_all_ones
632
633/**
634 * Non-zero/all ones check for arbitrary type of size <= 16 bytes
635 */
636#define OF_VARIABLE_IS_NON_ZERO(_ptr) \\
637 (MEMCMP(&of_all_zero_value, (_ptr), sizeof(*(_ptr))))
638#define OF_VARIABLE_IS_ALL_ONES(_ptr) \\
639 (!MEMCMP(&of_all_ones_value, (_ptr), sizeof(*(_ptr))))
640
641/* The octets object is a struct holding pointer and length */
642typedef struct of_octets_s {
643 uint8_t *data;
644 int bytes;
645} of_octets_t;
646
647/* Macro to convert an octet object to a pointer; currently trivial */
648#define OF_OCTETS_POINTER_GET(octet_ptr) ((octet_ptr)->data)
649#define OF_OCTETS_POINTER_SET(octet_ptr, ptr) (octet_ptr)->data = (ptr)
650#define OF_OCTETS_BYTES_GET(octet_ptr) ((octet_ptr)->bytes)
651#define OF_OCTETS_BYTES_SET(octet_ptr, bytes) (octet_ptr)->bytes = (bytes)
652
653/* Currently these are categorized as scalars */
654typedef char of_port_name_t[OF_MAX_PORT_NAME_LEN];
655typedef char of_table_name_t[OF_MAX_TABLE_NAME_LEN];
656typedef char of_desc_str_t[OF_DESC_STR_LEN];
657typedef char of_serial_num_t[OF_SERIAL_NUM_LEN];
Rich Lanef8a3d002014-03-19 13:33:52 -0700658typedef char of_str64_t[64];
Rich Lanea06d0c32013-03-25 08:52:03 -0700659
Rich Lane3b2fd832013-09-24 13:44:08 -0700660typedef struct of_bitmap_128_s {
661 uint64_t hi;
662 uint64_t lo;
663} of_bitmap_128_t;
664
Rich Lanefab0c822013-12-30 11:46:48 -0800665typedef struct of_checksum_128_s {
666 uint64_t hi;
667 uint64_t lo;
668} of_checksum_128_t;
669
Rich Lanea06d0c32013-03-25 08:52:03 -0700670/* These are types which change across versions. */
671typedef uint32_t of_port_no_t;
672typedef uint16_t of_fm_cmd_t;
673typedef uint64_t of_wc_bmap_t;
674typedef uint64_t of_match_bmap_t;
675
676#define MEMMOVE(dest, src, bytes) memmove(dest, src, bytes)
677#define MEMSET(dest, val, bytes) memset(dest, val, bytes)
678#define MEMCPY(dest, src, bytes) memcpy(dest, src, bytes)
679#define MEMCMP(a, b, bytes) memcmp(a, b, bytes)
680#define MALLOC(bytes) malloc(bytes)
681#define FREE(ptr) free(ptr)
682
683/** Try an operation and return on failure. */
684#define OF_TRY(op) do { \\
685 int _rv; \\
686 if ((_rv = (op)) < 0) { \\
687 LOCI_LOG_ERROR("ERROR %d at %s:%d\\n", _rv, __FILE__, __LINE__); \\
688 return _rv; \\
689 } \\
690 } while (0)
691
692/* The extent of an OF match object is determined by its length field, but
693 * aligned to 8 bytes
694 */
695
696#define OF_MATCH_BYTES(length) (((length) + 7) & 0xfff8)
697
Rich Lanedfcafae2014-03-06 16:56:49 -0800698#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
Rich Lanea06d0c32013-03-25 08:52:03 -0700699#define U16_NTOH(val) (val)
700#define U32_NTOH(val) (val)
701#define U64_NTOH(val) (val)
702#define IPV6_NTOH(dst, src) /* NOTE different syntax; currently no-op */
703#define U16_HTON(val) (val)
704#define U32_HTON(val) (val)
705#define U64_HTON(val) (val)
706#define IPV6_HTON(dst, src) /* NOTE different syntax; currently no-op */
707#else /* Little Endian */
Rich Lane69e247e2014-03-05 10:27:22 -0800708#define U16_NTOH(val) (((val) >> 8) | (((val) & 0xff) << 8))
Rich Lanea06d0c32013-03-25 08:52:03 -0700709#define U32_NTOH(val) ((((val) & 0xff000000) >> 24) | \\
710 (((val) & 0x00ff0000) >> 8) | \\
711 (((val) & 0x0000ff00) << 8) | \\
712 (((val) & 0x000000ff) << 24))
713#define U64_NTOH(val) ((((val) & 0xff00000000000000LL) >> 56) | \\
714 (((val) & 0x00ff000000000000LL) >> 40) | \\
715 (((val) & 0x0000ff0000000000LL) >> 24) | \\
716 (((val) & 0x000000ff00000000LL) >> 8) | \\
717 (((val) & 0x00000000ff000000LL) << 8) | \\
718 (((val) & 0x0000000000ff0000LL) << 24) | \\
719 (((val) & 0x000000000000ff00LL) << 40) | \\
720 (((val) & 0x00000000000000ffLL) << 56))
721#define IPV6_NTOH(dst, src) /* NOTE different syntax; currently no-op */
722#define U16_HTON(val) U16_NTOH(val)
723#define U32_HTON(val) U32_NTOH(val)
724#define U64_HTON(val) U64_NTOH(val)
725#define IPV6_HTON(dst, src) /* NOTE different syntax; currently no-op */
726#endif
Rich Lanea06d0c32013-03-25 08:52:03 -0700727""")
728
729def external_h_top_matter(out, name):
730 """
731 Generate top matter for external header file
732
733 @param name The name of the output file
734 @param out The output file object
735 """
736 common_top_matter(out, name)
737 out.write("""
738#include <loci/loci_base.h>
739#include <loci/of_message.h>
740#include <loci/of_match.h>
741#include <loci/of_object.h>
Rich Lanedef2e512013-12-15 15:54:02 -0800742#include <loci/loci_classes.h>
Rich Lanedc46fe22014-04-03 15:10:38 -0700743#include <loci/loci_class_metadata.h>
Rich Lanea06d0c32013-03-25 08:52:03 -0700744
745/****************************************************************
746 *
747 * This file is divided into the following sections.
748 *
749 * A few object specific macros
750 * Class typedefs (no struct definitions)
751 * Per-data type accessor function typedefs
752 * Per-class new/delete function typedefs
753 * Per-class static delete functions
754 * Per-class, per-member accessor declarations
755 * Per-class structure definitions
756 * Generic union (inheritance) definitions
757 * Pointer set function declarations
758 * Some special case macros
759 *
760 ****************************************************************/
761""")
762
Rich Lanea06d0c32013-03-25 08:52:03 -0700763################################################################
764#
765################################################################
766
767def gen_version_enum(out):
768 """
769 Generate the enumerated type for versions in LoxiGen
770 @param out The file object to which to write the decs
771
772 This just uses the wire versions for now
773 """
774 out.write("""
775/**
776 * Enumeration of OpenFlow versions
777 *
778 * The wire protocol numbers are currently used for values of the corresponding
779 * version identifiers.
780 */
781typedef enum of_version_e {
782 OF_VERSION_UNKNOWN = 0,
783""")
784
785 is_first = True
786 max = 0
787 for v in of_g.wire_ver_map:
788 if is_first:
789 is_first = False
790 else:
791 out.write(",\n")
792 if v > max:
793 max = v
794 out.write(" %s = %d" % (of_g.wire_ver_map[v], v))
795
796 out.write("""
797} of_version_t;
798
799/**
800 * @brief Use this when declaring arrays indexed by wire version
801 */
802#define OF_VERSION_ARRAY_MAX %d
803""" % (max + 1))
Andreas Wundsam53256162013-05-02 14:05:53 -0700804
Rich Lanea06d0c32013-03-25 08:52:03 -0700805def gen_object_enum(out):
806 """
807 Generate the enumerated type for object identification in LoxiGen
808 @param out The file object to which to write the decs
809 """
810 out.write("""
811
812/**
813 * Enumeration of OpenFlow objects
814 *
815 * We enumerate the OpenFlow objects used internally. Note that some
816 * message types are determined both by an outer type (message type like
817 * stats_request) and an inner type (port stats). These are different
818 * messages in ofC.
819 *
820 * These values are for internal use only. They will change with
821 * different versions of ofC.
822 */
823
824typedef enum of_object_id_e {
825 /* Root object type */
826 OF_OBJECT_INVALID = -1, /* "invalid" return value for mappings */
827 OF_OBJECT = 0, /* Generic, untyped object */
828
829 /* OpenFlow message objects */
830""")
831 last = 0
832 msg_count = 0
833 for cls in of_g.ordered_messages:
834 out.write(" %s = %d,\n" % (enum_name(cls),
835 of_g.unified[cls]["object_id"]))
836 msg_count = of_g.unified[cls]["object_id"] + 1
837
838 out.write("\n /* Non-message objects */\n")
839 for cls in of_g.ordered_non_messages:
840 out.write(" %s = %d,\n" % (enum_name(cls),
841 of_g.unified[cls]["object_id"]))
842 last = of_g.unified[cls]["object_id"]
843 out.write("\n /* List objects */\n")
844 for cls in of_g.ordered_list_objects:
845 out.write(" %s = %d,\n" % (enum_name(cls),
846 of_g.unified[cls]["object_id"]))
847 last = of_g.unified[cls]["object_id"]
848
Rich Lanea06d0c32013-03-25 08:52:03 -0700849 out.write("""
850 OF_OBJECT_COUNT = %d
851} of_object_id_t;
852
Rich Laneb157b0f2013-03-27 13:55:28 -0700853extern const char *const of_object_id_str[];
Rich Lanea06d0c32013-03-25 08:52:03 -0700854
855#define OF_MESSAGE_OBJECT_COUNT %d
856""" % ((last + 1), msg_count))
857
Rich Lanea06d0c32013-03-25 08:52:03 -0700858################################################################
859#
860# Internal Utility Functions
861#
862################################################################
863
864
865def acc_name(cls, m_name):
866 """
867 Generate the root name of an accessor function for typedef
868 @param cls The class name
869 @param m_name The member name
870 """
871 (m_type, get_rv) = get_acc_rv(cls, m_name)
872 return "%s_%s" % (cls, m_type)
873
874def get_acc_rv(cls, m_name):
875 """
876 Determine the data type and return type for a get accessor.
877
878 The return type may be "void" or it may be the accessor type
879 depending on the system configuration and on the data type.
880
881 @param cls The class name
882 @param m_name The member name
883 @return A pair (m_type, rv) where m_type is the unified type of the
884 member and rv is the get_accessor return type
885 """
886 member = of_g.unified[cls]["union"][m_name]
887 m_type = member["m_type"]
888 rv = "int"
Rich Lanea06d0c32013-03-25 08:52:03 -0700889 if m_type[-2:] == "_t":
890 m_type = m_type[:-2]
891
892 return (m_type, rv)
893
894def param_list(cls, m_name, a_type):
895 """
896 Generate the parameter list (no parens) for an a_type accessor
897 @param cls The class name
898 @param m_name The member name
899 @param a_type One of "set" or "get" or TBD
900 """
901 member = of_g.unified[cls]["union"][m_name]
902 m_type = member["m_type"]
903 params = ["%s_t *obj" % cls]
904 if a_type == "set":
905 if loxi_utils.type_is_scalar(m_type):
906 params.append("%s %s" % (m_type, m_name))
907 else:
908 params.append("%s *%s" % (m_type, m_name))
909 elif a_type in ["get", "bind"]:
910 params.append("%s *%s" % (m_type, m_name))
911 else:
912 debug("Class %s, name %s Bad param list a_type: %s" %
913 (cls, m_name, a_type))
914 sys.exit(1)
915 return params
916
Rich Lanea06d0c32013-03-25 08:52:03 -0700917def field_ver_get(cls, m_name):
918 """
919 Generate a dict, indexed by wire version, giving a pair (type, offset)
920
921 @param cls The class name
922 @param m_name The name of the class member
923
924 If offset is not known for m_name, the type
925 A dict is used for more convenient indexing.
926 """
927 result = {}
928
929 for ver in of_g.unified[cls]:
930 if type(ver) == type(0): # It's a version
931 if "use_version" in of_g.unified[cls][ver]: # deref version ref
932 ref_ver = of_g.unified[cls][ver]["use_version"]
933 members = of_g.unified[cls][ref_ver]["members"]
934 else:
935 members = of_g.unified[cls][ver]["members"]
936 idx = loxi_utils.member_to_index(m_name, members)
937 if (idx < 0):
938 continue # Member not in this version
939 m_type = members[idx]["m_type"]
940 offset = members[idx]["offset"]
941
942 # If m_type is mixed, get wire version type from global data
943 if m_type in of_g.of_mixed_types and \
944 ver in of_g.of_mixed_types[m_type]:
945 m_type = of_g.of_mixed_types[m_type][ver]
946
947 # add version to result list
948 result[ver] = (m_type, offset)
949
950 return result
951
952def v3_match_offset_get(cls):
953 """
Andreas Wundsam53256162013-05-02 14:05:53 -0700954 Return the offset of an OF 1.2 match in an object if it has such;
Rich Lanea06d0c32013-03-25 08:52:03 -0700955 otherwise return -1
956 """
957 result = field_ver_get(cls, "match")
958 if of_g.VERSION_1_2 in result:
959 if result[of_g.VERSION_1_2][0] == "of_match_v3_t":
960 return result[of_g.VERSION_1_2][1]
961 return -1
962
963################################################################
964#
965# OpenFlow Object Definitions
966#
967################################################################
968
Rich Lanea06d0c32013-03-25 08:52:03 -0700969def gen_generics(out):
970 for (cls, subclasses) in type_maps.inheritance_map.items():
971 out.write("""
972/**
973 * Inheritance super class for %(cls)s
974 *
975 * This class is the union of %(cls)s classes. You can refer
976 * to it untyped by refering to the member 'header' whose structure
977 * is common across all sub-classes.
978 */
979
980union %(cls)s_u {
981 %(cls)s_header_t header; /* Generic instance */
982""" % dict(cls=cls))
983 for subcls in sorted(subclasses):
Rich Laneee60d4e2014-10-12 20:08:24 -0700984 instance = loxi_utils.class_to_instance(subcls, cls)
985 out.write(" %s_%s_t %s;\n" % (cls, instance, instance))
Rich Lanea06d0c32013-03-25 08:52:03 -0700986 out.write("};\n")
987
988def gen_struct_typedefs(out):
989 """
990 Generate typedefs for all struct objects
991 @param out The file for output, already open
992 """
993
994 out.write("\n/* LOCI inheritance parent typedefs */\n")
995 for cls in type_maps.inheritance_map:
996 out.write("typedef union %(cls)s_u %(cls)s_t;\n" % dict(cls=cls))
997 out.write("\n/* LOCI object typedefs */\n")
998 for cls in of_g.standard_class_order:
Rich Lane8841f352014-10-12 19:18:36 -0700999 if type_maps.class_is_inheritance_root(cls):
Rich Lanea06d0c32013-03-25 08:52:03 -07001000 continue
Rich Lane85767872013-12-15 16:24:42 -08001001 template = "typedef of_object_t %(cls)s_t;\n"
1002 out.write(template % dict(cls=cls))
Rich Lanea06d0c32013-03-25 08:52:03 -07001003
1004 out.write("""
1005/****************************************************************
1006 *
1007 * Additional of_object defines
1008 * These are needed for some static inline ops, so we put them here.
1009 *
1010 ****************************************************************/
1011
1012/* Delete an OpenFlow object without reference to its type */
1013extern void of_object_delete(of_object_t *obj);
1014
1015""")
1016
Rich Lanea06d0c32013-03-25 08:52:03 -07001017################################################################
1018#
Rich Lanea06d0c32013-03-25 08:52:03 -07001019# Accessor Functions
1020#
1021################################################################
1022
Andreas Wundsam53256162013-05-02 14:05:53 -07001023
Rich Lanea06d0c32013-03-25 08:52:03 -07001024def gen_accessor_declarations(out):
1025 """
1026 Generate the declaration of each version independent accessor
1027
1028 @param out The file to which to write the decs
1029 """
1030
1031 out.write("""
1032/****************************************************************
1033 *
1034 * Unified, per-member accessor function declarations
1035 *
1036 ****************************************************************/
1037""")
1038 for cls in of_g.standard_class_order:
Rich Lane8841f352014-10-12 19:18:36 -07001039 if type_maps.class_is_inheritance_root(cls):
Rich Lanea06d0c32013-03-25 08:52:03 -07001040 continue
1041 out.write("\n/* Unified accessor functions for %s */\n" % cls)
1042 for m_name in of_g.ordered_members[cls]:
1043 if m_name in of_g.skip_members:
1044 continue
1045 m_type = loxi_utils.member_base_type(cls, m_name)
1046 base_name = "%s_%s" % (cls, m_name)
1047 gparams = ",\n ".join(param_list(cls, m_name, "get"))
1048 get_ret_type = accessor_return_type("get", m_type)
1049 sparams = ",\n ".join(param_list(cls, m_name, "set"))
1050 set_ret_type = accessor_return_type("set", m_type)
1051 bparams = ",\n ".join(param_list(cls, m_name, "bind"))
1052 bind_ret_type = accessor_return_type("bind", m_type)
1053
1054 if loxi_utils.type_is_of_object(m_type):
1055 # Generate bind accessors, but not get accessor
1056 out.write("""
1057extern %(set_ret_type)s %(base_name)s_set(
1058 %(sparams)s);
1059extern %(bind_ret_type)s %(base_name)s_bind(
1060 %(bparams)s);
1061extern %(m_type)s *%(cls)s_%(m_name)s_get(
1062 %(cls)s_t *obj);
1063""" % dict(base_name=base_name, sparams=sparams, bparams=bparams,
1064 m_name=m_name, m_type=m_type, cls=cls,
1065 set_ret_type=set_ret_type, bind_ret_type=bind_ret_type))
1066 else:
1067 out.write("""
1068extern %(set_ret_type)s %(base_name)s_set(
1069 %(sparams)s);
1070extern %(get_ret_type)s %(base_name)s_get(
1071 %(gparams)s);
1072""" % dict(base_name=base_name, gparams=gparams, sparams=sparams,
1073 get_ret_type=get_ret_type, set_ret_type=set_ret_type))
Andreas Wundsam53256162013-05-02 14:05:53 -07001074
Rich Lanea06d0c32013-03-25 08:52:03 -07001075 if loxi_utils.class_is_list(cls):
1076 e_type = loxi_utils.list_to_entry_type(cls)
1077 out.write("""
1078extern int %(cls)s_first(
1079 %(cls)s_t *list, %(e_type)s_t *obj);
1080extern int %(cls)s_next(
1081 %(cls)s_t *list, %(e_type)s_t *obj);
1082extern int %(cls)s_append_bind(
1083 %(cls)s_t *list, %(e_type)s_t *obj);
1084extern int %(cls)s_append(
1085 %(cls)s_t *list, %(e_type)s_t *obj);
1086
1087/**
1088 * Iteration macro for list of type %(cls)s
1089 * @param list Pointer to the list being iterated over of
1090 * type %(cls)s
1091 * @param elt Pointer to an element of type %(e_type)s
1092 * @param rv On exiting the loop will have the value OF_ERROR_RANGE.
1093 */
1094#define %(u_cls)s_ITER(list, elt, rv) \\
1095 for ((rv) = %(cls)s_first((list), (elt)); \\
1096 (rv) == OF_ERROR_NONE; \\
1097 (rv) = %(cls)s_next((list), (elt)))
1098""" % dict(u_cls=cls.upper(), cls=cls, e_type=e_type))
1099
1100
1101def wire_accessor(m_type, a_type):
1102 """
1103 Returns the name of the a_type accessor for low level wire buff offset
1104 @param m_type The member type
1105 @param a_type The accessor type (set or get)
1106 """
1107 # Strip off _t if present
1108 if m_type in of_g.of_base_types:
1109 m_type = of_g.of_base_types[m_type]["short_name"]
1110 if m_type in of_g.of_mixed_types:
1111 m_type = of_g.of_mixed_types[m_type]["short_name"]
1112 if m_type[-2:] == "_t":
1113 m_type = m_type[:-2]
1114 if m_type == "octets":
1115 m_type = "octets_data"
1116 return "of_wire_buffer_%s_%s" % (m_type, a_type)
1117
Rich Lane713d9282013-12-30 15:21:35 -08001118def get_len_macro(cls, m_name, m_type, version):
Rich Lanea06d0c32013-03-25 08:52:03 -07001119 """
1120 Get the length macro for m_type in cls
1121 """
1122 if m_type.find("of_match") == 0:
1123 return "_WIRE_MATCH_PADDED_LEN(obj, offset)"
1124 if m_type.find("of_list_oxm") == 0:
1125 return "wire_match_len(obj, 0) - 4"
1126 if loxi_utils.class_is_tlv16(m_type):
1127 return "_TLV16_LEN(obj, offset)"
1128 if cls == "of_packet_out" and m_type == "of_list_action_t":
1129 return "_PACKET_OUT_ACTION_LEN(obj)"
Rich Lane713d9282013-12-30 15:21:35 -08001130 if cls == "of_bsn_gentable_entry_add" and m_name == "key":
1131 return "of_object_u16_get(obj, 18)"
1132 if cls == "of_bsn_gentable_entry_desc_stats_entry" and m_name == "key":
1133 return "of_object_u16_get(obj, 2)"
1134 if cls == "of_bsn_gentable_entry_stats_entry" and m_name == "key":
1135 return "of_object_u16_get(obj, 2)"
Rich Lanea06d0c32013-03-25 08:52:03 -07001136 # Default is everything to the end of the object
1137 return "_END_LEN(obj, offset)"
1138
1139def gen_accessor_offsets(out, cls, m_name, version, a_type, m_type, offset):
1140 """
1141 Generate the sub-object offset and length calculations for accessors
1142 @param out File being written
1143 @param m_name Name of member
1144 @param version Wire version being processed
1145 @param a_type The accessor type (set or get)
1146 @param m_type The original member type
1147 @param offset The offset of the object or -1 if not fixed
1148 """
1149 # determine offset
1150 o_str = "%d" % offset # Default is fixed length
1151 if offset == -1:
1152 # There are currently 4 special cases for this
1153 # In general, get offset and length of predecessor
1154 if (loxi_utils.cls_is_flow_mod(cls) and m_name == "instructions"):
1155 pass
1156 elif (cls == "of_flow_stats_entry" and m_name == "instructions"):
1157 pass
1158 elif (cls == "of_packet_in" and m_name == "data"):
1159 pass
1160 elif (cls == "of_packet_out" and m_name == "data"):
1161 pass
Rich Lane713d9282013-12-30 15:21:35 -08001162 elif (cls == "of_bsn_gentable_entry_add" and m_name == "value"):
1163 pass
1164 elif (cls == "of_bsn_gentable_entry_desc_stats_entry" and m_name == "value"):
1165 pass
1166 elif (cls == "of_bsn_gentable_entry_stats_entry" and m_name == "stats"):
1167 pass
Rich Lanea06d0c32013-03-25 08:52:03 -07001168 else:
1169 debug("Error: Unknown member with offset == -1")
1170 debug(" cls %s, m_name %s, version %d" % (cls, m_name, version))
1171 sys.exit(1)
1172 o_str = "_%s_%s_OFFSET(obj)" % (cls.upper()[3:], m_name.upper())
1173
1174 out.write("""\
1175 offset = %s;
1176""" % o_str);
1177
1178 # This could be moved to main body but for version check
1179 if not loxi_utils.type_is_scalar(m_type):
1180 if loxi_utils.class_is_var_len(m_type[:-2], version) or \
1181 m_type == "of_match_t":
Rich Lane713d9282013-12-30 15:21:35 -08001182 len_macro = get_len_macro(cls, m_name, m_type, version)
Rich Lanea06d0c32013-03-25 08:52:03 -07001183 else:
1184 len_macro = "%d" % of_g.base_length[(m_type[:-2], version)]
1185 out.write(" cur_len = %s;\n" % len_macro)
1186 out.write(" break;\n")
1187
1188def length_of(m_type, version):
1189 """
1190 Return the length of a type based on the version
1191 """
1192 if m_type in of_g.of_mixed_types:
1193 m_type = of_g.of_mixed_types[m_type][version]
1194 if m_type in of_g.of_base_types:
1195 return of_g.of_base_types[m_type]["bytes"]
1196 if (m_type[:-2], version) in of_g.base_length:
1197 return of_g.base_length[(m_type[:-2], version)]
1198 print "Unknown length request", m_type, version
1199 sys.exit(1)
Andreas Wundsam53256162013-05-02 14:05:53 -07001200
Rich Lanea06d0c32013-03-25 08:52:03 -07001201
1202def gen_get_accessor_body(out, cls, m_type, m_name):
1203 """
1204 Generate the common operations for a get accessor
1205 """
1206 if loxi_utils.type_is_scalar(m_type):
1207 ver = "" # See if version required for scalar update
1208 if m_type in of_g.of_mixed_types:
1209 ver = "ver, "
1210 out.write("""\
1211 %(wa)s(%(ver)swbuf, abs_offset, %(m_name)s);
1212""" % dict(wa=wire_accessor(m_type, "get"), ver=ver, m_name=m_name))
1213
1214 if m_type == "of_port_no_t":
1215 out.write(" OF_PORT_NO_VALUE_CHECK(*%s, ver);\n" % m_name)
1216 elif m_type == "of_octets_t":
1217 out.write("""\
Rich Lanee57f0432014-02-19 10:31:53 -08001218 LOCI_ASSERT(cur_len + abs_offset <= WBUF_CURRENT_BYTES(wbuf));
Rich Lanea06d0c32013-03-25 08:52:03 -07001219 %(m_name)s->bytes = cur_len;
1220 %(m_name)s->data = OF_WIRE_BUFFER_INDEX(wbuf, abs_offset);
1221""" % dict(m_name=m_name))
1222 elif m_type == "of_match_t":
1223 out.write("""
Rich Lanee57f0432014-02-19 10:31:53 -08001224 LOCI_ASSERT(cur_len + abs_offset <= WBUF_CURRENT_BYTES(wbuf));
Rich Lanee0b70cc2014-06-12 15:02:22 -07001225 OF_TRY(of_match_deserialize(ver, %(m_name)s, obj, offset, cur_len));
Rich Lanea06d0c32013-03-25 08:52:03 -07001226""" % dict(m_name=m_name))
Rich Lane90020b42014-04-07 12:05:45 -07001227 elif m_type == "of_oxm_header_t":
1228 out.write("""
1229 /* Initialize child */
1230 %(m_type)s_init(%(m_name)s, obj->version, 0, 1);
1231 /* Attach to parent */
Rich Laned1fe6972014-06-12 14:53:24 -07001232 of_object_attach(obj, %(m_name)s, offset, cur_len);
Rich Lane90020b42014-04-07 12:05:45 -07001233 of_object_wire_init(%(m_name)s, OF_OXM, 0);
1234""" % dict(m_type=m_type[:-2], m_name=m_name))
Wilson Ngd6181882014-04-14 16:28:35 -07001235 elif m_type == "of_bsn_vport_header_t":
1236 out.write("""
1237 /* Initialize child */
1238 %(m_type)s_init(%(m_name)s, obj->version, 0, 1);
1239 /* Attach to parent */
Rich Laned1fe6972014-06-12 14:53:24 -07001240 of_object_attach(obj, %(m_name)s, offset, cur_len);
Wilson Ngd6181882014-04-14 16:28:35 -07001241 of_object_wire_init(%(m_name)s, OF_BSN_VPORT, 0);
1242""" % dict(m_type=m_type[:-2], m_name=m_name))
Rich Lanea06d0c32013-03-25 08:52:03 -07001243 else:
1244 out.write("""
1245 /* Initialize child */
1246 %(m_type)s_init(%(m_name)s, obj->version, 0, 1);
1247 /* Attach to parent */
Rich Laned1fe6972014-06-12 14:53:24 -07001248 of_object_attach(obj, %(m_name)s, offset, cur_len);
Rich Lanea06d0c32013-03-25 08:52:03 -07001249""" % dict(m_type=m_type[:-2], m_name=m_name))
1250
1251
1252def gen_set_accessor_body(out, cls, m_type, m_name):
1253 """
1254 Generate the contents of a set accessor
1255 """
1256 if loxi_utils.type_is_scalar(m_type) or m_type == "of_octets_t":
1257 ver = "" # See if version required for scalar update
1258 if m_type in of_g.of_mixed_types:
1259 ver = "ver, "
1260 cur_len = "" # See if version required for scalar update
1261 if m_type == "of_octets_t":
1262 cur_len = ", cur_len"
1263 out.write("""\
1264 new_len = %(m_name)s->bytes;
1265 of_wire_buffer_grow(wbuf, abs_offset + (new_len - cur_len));
1266""" % dict(m_name=m_name))
1267 out.write("""\
1268 %(wa)s(%(ver)swbuf, abs_offset, %(m_name)s%(cur_len)s);
1269""" % dict(wa=wire_accessor(m_type, "set"), ver=ver, cur_len=cur_len,
1270 m_name=m_name))
1271
1272 elif m_type == "of_match_t":
1273 out.write("""
Rich Lanee0b70cc2014-06-12 15:02:22 -07001274 {
1275 /* Match object */
1276 of_octets_t match_octets;
1277 OF_TRY(of_match_serialize(ver, %(m_name)s, &match_octets));
1278 new_len = match_octets.bytes;
1279 of_wire_buffer_replace_data(wbuf, abs_offset, cur_len,
1280 match_octets.data, new_len);
1281 /* Free match serialized octets */
1282 FREE(match_octets.data);
1283 }
Rich Lanea06d0c32013-03-25 08:52:03 -07001284""" % dict(m_name=m_name))
1285
1286 else: # Other object type
1287 out.write("\n /* LOCI object type */")
1288 # Need to special case OXM list
1289 out.write("""
1290 new_len = %(m_name)s->length;
1291 /* If underlying buffer already shared; nothing to do */
Rich Lanecdd542d2014-04-03 16:13:12 -07001292 if (obj->wbuf == %(m_name)s->wbuf) {
Rich Lanea06d0c32013-03-25 08:52:03 -07001293 of_wire_buffer_grow(wbuf, abs_offset + new_len);
1294 /* Verify that the offsets are correct */
Rich Lanee57f0432014-02-19 10:31:53 -08001295 LOCI_ASSERT(abs_offset == OF_OBJECT_ABSOLUTE_OFFSET(%(m_name)s, 0));
1296 /* LOCI_ASSERT(new_len == cur_len); */ /* fixme: may fail for OXM lists */
Rich Lanea06d0c32013-03-25 08:52:03 -07001297 return %(ret_success)s;
1298 }
1299
1300 /* Otherwise, replace existing object in data buffer */
1301 of_wire_buffer_replace_data(wbuf, abs_offset, cur_len,
1302 OF_OBJECT_BUFFER_INDEX(%(m_name)s, 0), new_len);
1303""" % dict(m_name=m_name, ret_success=accessor_return_success("set", m_type)))
1304
1305 if not loxi_utils.type_is_scalar(m_type):
1306 if cls == "of_packet_out" and m_type == "of_list_action_t":
1307 out.write("""
1308 /* Special case for setting action lengths */
1309 _PACKET_OUT_ACTION_LEN_SET(obj, %(m_name)s->length);
1310""" % dict(m_name=m_name))
Rich Lane713d9282013-12-30 15:21:35 -08001311 elif cls == "of_bsn_gentable_entry_add" and m_name == "key":
1312 out.write("""
1313 /* Special case for setting key length */
1314 of_object_u16_set(obj, 18, %(m_name)s->length);
1315""" % dict(m_name=m_name))
1316 elif cls in ["of_bsn_gentable_entry_desc_stats_entry", "of_bsn_gentable_entry_stats_entry"] and m_name == "key":
1317 out.write("""
1318 /* Special case for setting key length */
1319 of_object_u16_set(obj, 2, %(m_name)s->length);
1320""" % dict(m_name=m_name))
Rich Lanea06d0c32013-03-25 08:52:03 -07001321 elif m_type not in ["of_match_t", "of_octets_t"]:
1322 out.write("""
1323 /* @fixme Shouldn't this precede copying value's data to buffer? */
Rich Lanedc46fe22014-04-03 15:10:38 -07001324 of_object_wire_length_set((of_object_t *)%(m_name)s, %(m_name)s->length);
Rich Lanea06d0c32013-03-25 08:52:03 -07001325""" % dict(m_name=m_name))
1326 out.write("""
1327 /* Not scalar, update lengths if needed */
1328 delta = new_len - cur_len;
1329 if (delta != 0) {
1330 /* Update parent(s) */
1331 of_object_parent_length_update((of_object_t *)obj, delta);
1332 }
1333""")
1334
1335def obj_assert_check(cls):
1336 """
1337 The body of the assert check for an accessor
1338 We allow all versions of add/delete/modify to use the same accessors
1339 """
1340 if cls in ["of_flow_modify", "of_flow_modify_strict",
1341 "of_flow_delete", "of_flow_delete_strict",
1342 "of_flow_add"]:
1343 return "IS_FLOW_MOD_SUBTYPE(obj->object_id)"
1344 else:
1345 return "obj->object_id == %s" % cls.upper()
1346
1347def gen_of_object_get(out, cls, m_name, m_type):
1348 sub_cls = m_type[:-2]
1349 out.write("""
1350/**
Andreas Wundsam53256162013-05-02 14:05:53 -07001351 * Create a copy of %(m_name)s into a new variable of type %(m_type)s from
Rich Lanea06d0c32013-03-25 08:52:03 -07001352 * a %(cls)s instance.
1353 *
1354 * @param obj Pointer to the source of type %(cls)s_t
1355 * @returns A pointer to a new instance of type %(m_type)s whose contents
1356 * match that of %(m_name)s from source
1357 * @returns NULL if an error occurs
1358 */
1359%(m_type)s *
1360%(cls)s_%(m_name)s_get(%(cls)s_t *obj) {
1361 %(m_type)s _%(m_name)s;
1362 %(m_type)s *_%(m_name)s_ptr;
1363
1364 %(cls)s_%(m_name)s_bind(obj, &_%(m_name)s);
1365 _%(m_name)s_ptr = (%(m_type)s *)of_object_dup(&_%(m_name)s);
1366 return _%(m_name)s_ptr;
1367}
1368""" % dict(m_name=m_name, m_type=m_type, cls=cls, sub_cls=sub_cls))
1369
1370def gen_unified_acc_body(out, cls, m_name, ver_type_map, a_type, m_type):
1371 """
1372 Generate the body of a set or get accessor function
1373
1374 @param out The file to which to write the decs
1375 @param cls The class name
1376 @param m_name The member name
1377 @param ver_type_map Maps (type, offset) pairs to a list of versions
1378 @param a_type The accessor type, set or get
1379 @param m_type The original member type
1380
1381 The type values in ver_type_map are now ignored as we've pushed down
1382 the type munging to the lower level.
1383
1384 This is unified because the version switch case processing is the
1385 same for both set and get
1386 """
1387 out.write("""{
1388 of_wire_buffer_t *wbuf;
1389 int offset = 0; /* Offset of value relative to the start obj */
1390 int abs_offset; /* Offset of value relative to start of wbuf */
1391 of_version_t ver;
1392""")
1393
1394 if not loxi_utils.type_is_scalar(m_type):
1395 out.write("""\
1396 int cur_len = 0; /* Current length of object data */
1397""")
1398 if a_type == "set":
1399 out.write("""\
1400 int new_len, delta; /* For set, need new length and delta */
1401""")
1402
Rich Lanea06d0c32013-03-25 08:52:03 -07001403 out.write("""
Rich Lanee57f0432014-02-19 10:31:53 -08001404 LOCI_ASSERT(%(assert_str)s);
Rich Lanea06d0c32013-03-25 08:52:03 -07001405 ver = obj->version;
1406 wbuf = OF_OBJECT_TO_WBUF(obj);
Rich Lanee57f0432014-02-19 10:31:53 -08001407 LOCI_ASSERT(wbuf != NULL);
Rich Lanea06d0c32013-03-25 08:52:03 -07001408
1409 /* By version, determine offset and current length (where needed) */
1410 switch (ver) {
1411""" % dict(assert_str=obj_assert_check(cls)))
1412
1413 for first in sorted(ver_type_map):
1414 (prev_t, prev_o) = ver_type_map[first]
1415 prev_len = length_of(prev_t, first)
1416 prev = first
1417 out.write(" case %s:\n" % of_g.wire_ver_map[first])
1418 break
1419
1420 for next in sorted(ver_type_map):
1421 if next == first:
1422 continue
1423
1424 (t, o) = ver_type_map[next]
1425 cur_len = length_of(t, next)
1426 if o == prev_o and cur_len == prev_len:
1427 out.write(" case %s:\n" % of_g.wire_ver_map[next])
1428 continue
1429 gen_accessor_offsets(out, cls, m_name, prev, a_type, m_type, prev_o)
1430 out.write(" case %s:\n" % of_g.wire_ver_map[next])
1431 (prev_t, prev_o, prev_len, prev) = (t, o, cur_len, next)
1432
1433 gen_accessor_offsets(out, cls, m_name, next, a_type, m_type, prev_o)
1434 out.write("""\
1435 default:
Rich Lanee57f0432014-02-19 10:31:53 -08001436 LOCI_ASSERT(0);
Rich Lanea06d0c32013-03-25 08:52:03 -07001437 }
1438
1439 abs_offset = OF_OBJECT_ABSOLUTE_OFFSET(obj, offset);
Rich Lanee57f0432014-02-19 10:31:53 -08001440 LOCI_ASSERT(abs_offset >= 0);
Rich Lanea06d0c32013-03-25 08:52:03 -07001441""")
1442 if not loxi_utils.type_is_scalar(m_type):
Rich Lanee57f0432014-02-19 10:31:53 -08001443 out.write(" LOCI_ASSERT(cur_len >= 0 && cur_len < 64 * 1024);\n")
Rich Lanea06d0c32013-03-25 08:52:03 -07001444
1445 # Now generate the common accessor code
1446 if a_type in ["get", "bind"]:
1447 gen_get_accessor_body(out, cls, m_type, m_name)
1448 else:
1449 gen_set_accessor_body(out, cls, m_type, m_name)
1450
1451 out.write("""
1452 OF_LENGTH_CHECK_ASSERT(obj);
1453
1454 return %s;
1455}
1456""" % accessor_return_success(a_type, m_type))
1457
1458def gen_of_obj_bind(out, cls, m_name, m_type, ver_type_map):
1459 """
1460 For generating the bind call for OF sub-objects
1461 """
1462
1463 params = ",\n ".join(param_list(cls, m_name, "bind"))
1464 out.write("""
1465/**
1466 * Bind an object of type %(m_type)s to the parent of type %(cls)s for
1467 * member %(m_name)s
1468 * @param obj Pointer to an object of type %(cls)s.
1469 * @param %(m_name)s Pointer to the child object of type
1470 * %(m_type)s to be filled out.
1471 * \ingroup %(cls)s
1472 *
1473 * The parameter %(m_name)s is filled out to point to the same underlying
1474 * wire buffer as its parent.
1475 *
1476 */
1477""" % dict(m_name=m_name, cls=cls, m_type=m_type))
1478
1479 ret_type = accessor_return_type("bind", m_type)
1480 out.write("%s\n%s_%s_bind(\n %s)\n" % (ret_type, cls, m_name, params))
1481 gen_unified_acc_body(out, cls, m_name, ver_type_map, "bind", m_type)
1482
1483def gen_get_accessor(out, cls, m_name, m_type, ver_type_map):
1484 """
1485 For generating the get call for non- OF sub-objects
1486 """
1487 params = ",\n ".join(param_list(cls, m_name, "get"))
1488 out.write("""
1489/**
1490 * Get %(m_name)s from an object of type %(cls)s.
1491 * @param obj Pointer to an object of type %(cls)s.
1492 * @param %(m_name)s Pointer to the child object of type
1493 * %(m_type)s to be filled out.
1494 *
1495 */
1496""" % dict(m_name=m_name, cls=cls, m_type=m_type))
1497
1498 ret_type = accessor_return_type("get", m_type)
1499 out.write("%s\n%s_%s_get(\n %s)\n" % (ret_type, cls, m_name, params))
1500 gen_unified_acc_body(out, cls, m_name, ver_type_map, "get", m_type)
1501
Rich Lanece2e4642013-12-15 12:05:45 -08001502def gen_accessor_definitions(out, cls):
Rich Lanea06d0c32013-03-25 08:52:03 -07001503 for m_name in of_g.ordered_members[cls]:
1504 if m_name in of_g.skip_members:
1505 continue
1506 m_type = loxi_utils.member_base_type(cls, m_name)
1507 ver_type_map = field_ver_get(cls, m_name)
1508
1509 # Generate get/bind pending on member type
1510 # FIXME: Does this do the right thing for match?
1511 if loxi_utils.type_is_of_object(m_type):
1512 gen_of_obj_bind(out, cls, m_name, m_type, ver_type_map)
1513 gen_of_object_get(out, cls, m_name, m_type)
1514 else:
1515 gen_get_accessor(out, cls, m_name, m_type, ver_type_map)
1516
1517 # Now generate set accessor for all objects
1518 params = ",\n ".join(param_list(cls, m_name, "set"))
1519 out.write("""
1520/**
1521 * Set %(m_name)s in an object of type %(cls)s.
1522 * @param obj Pointer to an object of type %(cls)s.
1523""" % dict(m_name=m_name, cls=cls, m_type=m_type))
1524 if loxi_utils.type_is_scalar(m_type) or m_type == "of_octets_t":
1525 out.write("""\
1526 * @param %(m_name)s The value to write into the object
1527 */
1528""" % dict(m_name=m_name, cls=cls, m_type=m_type))
1529 else:
1530 out.write("""\
1531 * @param %(m_name)s Pointer to the child of type %(m_type)s.
1532 *
1533 * If the child's wire buffer is the same as the parent's, then
1534 * nothing is done as the changes have already been registered in the
1535 * parent. Otherwise, the data in the child's wire buffer is inserted
1536 * into the parent's and the appropriate lengths are updated.
1537 */
1538""" % dict(m_name=m_name, cls=cls, m_type=m_type))
1539 ret_type = accessor_return_type("set", m_type)
1540 out.write("%s\n%s_%s_set(\n %s)\n" % (ret_type, cls, m_name, params))
1541 gen_unified_acc_body(out, cls, m_name, ver_type_map, "set", m_type)
1542
Rich Lanea06d0c32013-03-25 08:52:03 -07001543################################################################
1544#
1545# New/Delete Function Definitions
1546#
1547################################################################
1548
Rich Lanea06d0c32013-03-25 08:52:03 -07001549################################################################
1550# Routines to generate the body of new/delete functions
1551################################################################
1552
1553def gen_init_fn_body(cls, out):
1554 """
1555 Generate function body for init function
1556 @param cls The class name for the function
1557 @param out The file to which to write
1558 """
Rich Lane8841f352014-10-12 19:18:36 -07001559 if type_maps.class_is_inheritance_root(cls):
Rich Lanea06d0c32013-03-25 08:52:03 -07001560 param = "obj_p"
1561 else:
1562 param = "obj"
1563
1564 out.write("""
1565/**
1566 * Initialize an object of type %(cls)s.
1567 *
1568 * @param obj Pointer to the object to initialize
1569 * @param version The wire version to use for the object
1570 * @param bytes How many bytes in the object
1571 * @param clean_wire Boolean: If true, clear the wire object control struct
1572 *
1573 * If bytes < 0, then the default fixed length is used for the object
1574 *
1575 * This is a "coerce" function that sets up the pointers for the
Andreas Wundsam53256162013-05-02 14:05:53 -07001576 * accessors properly.
Rich Lanea06d0c32013-03-25 08:52:03 -07001577 *
1578 * If anything other than 0 is passed in for the buffer size, the underlying
1579 * wire buffer will have 'grow' called.
1580 */
1581
1582void
1583%(cls)s_init(%(cls)s_t *%(param)s,
1584 of_version_t version, int bytes, int clean_wire)
1585{
1586""" % dict(cls=cls, param=param))
1587
1588 # Use an extra pointer to deal with inheritance classes
Rich Lane8841f352014-10-12 19:18:36 -07001589 if type_maps.class_is_inheritance_root(cls):
Rich Lanea06d0c32013-03-25 08:52:03 -07001590 out.write("""\
1591 %s_header_t *obj;
1592
1593 obj = &obj_p->header; /* Need instantiable subclass */
1594""" % cls)
1595
1596 out.write("""
Rich Lanee57f0432014-02-19 10:31:53 -08001597 LOCI_ASSERT(of_object_fixed_len[version][%(enum)s] >= 0);
Rich Lanea06d0c32013-03-25 08:52:03 -07001598 if (clean_wire) {
1599 MEMSET(obj, 0, sizeof(*obj));
1600 }
1601 if (bytes < 0) {
Rich Lanee3d3fb52014-10-16 12:45:17 -07001602 bytes = of_object_fixed_len[version][%(enum)s];
Rich Lanea06d0c32013-03-25 08:52:03 -07001603 }
1604 obj->version = version;
1605 obj->length = bytes;
1606 obj->object_id = %(enum)s;
1607""" % dict(cls=cls, enum=enum_name(cls)))
Rich Lanea06d0c32013-03-25 08:52:03 -07001608
1609 out.write("""
1610 /* Grow the wire buffer */
Rich Lanecdd542d2014-04-03 16:13:12 -07001611 if (obj->wbuf != NULL) {
Rich Lanea06d0c32013-03-25 08:52:03 -07001612 int tot_bytes;
1613
Rich Lanecdd542d2014-04-03 16:13:12 -07001614 tot_bytes = bytes + obj->obj_offset;
1615 of_wire_buffer_grow(obj->wbuf, tot_bytes);
Rich Lanea06d0c32013-03-25 08:52:03 -07001616 }
1617}
1618
1619""")
1620
Rich Lanea06d0c32013-03-25 08:52:03 -07001621def gen_new_fn_body(cls, out):
1622 """
1623 Generate function body for new function
1624 @param cls The class name for the function
1625 @param out The file to which to write
1626 """
1627
1628 out.write("""
1629/**
1630 * \\defgroup %(cls)s %(cls)s
1631 */
1632""" % dict(cls=cls))
1633
Rich Lane37911fd2014-04-01 22:11:22 -07001634 uclass = loxi_globals.unified.class_by_name(cls)
1635 is_fixed_length = uclass and uclass.is_fixed_length
1636 max_length = is_fixed_length and "bytes" or "OF_WIRE_BUFFER_MAX_LENGTH"
1637
Rich Lanea06d0c32013-03-25 08:52:03 -07001638 out.write("""
1639/**
1640 * Create a new %(cls)s object
1641 *
1642 * @param version The wire version to use for the object
1643 * @return Pointer to the newly create object or NULL on error
1644 *
1645 * Initializes the new object with it's default fixed length associating
1646 * a new underlying wire buffer.
1647 *
Rich Lanea06d0c32013-03-25 08:52:03 -07001648 * \\ingroup %(cls)s
1649 */
1650
1651%(cls)s_t *
Rich Lanecd6ef152013-12-15 16:42:18 -08001652%(cls)s_new(of_version_t version)
Rich Lanea06d0c32013-03-25 08:52:03 -07001653{
1654 %(cls)s_t *obj;
1655 int bytes;
1656
Rich Lanee3d3fb52014-10-16 12:45:17 -07001657 bytes = of_object_fixed_len[version][%(enum)s];
Rich Lanea06d0c32013-03-25 08:52:03 -07001658
Rich Lane37911fd2014-04-01 22:11:22 -07001659 if ((obj = (%(cls)s_t *)of_object_new(%(max_length)s)) == NULL) {
Rich Lanea06d0c32013-03-25 08:52:03 -07001660 return NULL;
1661 }
1662
1663 %(cls)s_init(obj, version, bytes, 0);
Rich Lane37911fd2014-04-01 22:11:22 -07001664""" % dict(cls=cls, enum=enum_name(cls), max_length=max_length))
Rich Lanea06d0c32013-03-25 08:52:03 -07001665 if not type_maps.class_is_virtual(cls):
Rich Lane7e003102014-10-14 10:40:48 -07001666 from codegen import class_metadata_dict
1667 metadata = class_metadata_dict[cls]
1668
1669 if metadata.wire_type_set != 'NULL':
1670 out.write("""\
1671 %s(obj);
1672""" % metadata.wire_type_set)
1673
1674 if metadata.wire_length_set != 'NULL':
1675 out.write("""\
1676 %s(obj, obj->length);
1677""" % metadata.wire_length_set)
Rich Lanea06d0c32013-03-25 08:52:03 -07001678
1679 match_offset = v3_match_offset_get(cls)
1680 if match_offset >= 0:
1681 # Init length field for match object
1682 out.write("""
1683 /* Initialize match TLV for 1.2 */
Rich Lanea926e312014-10-14 11:45:39 -07001684 if ((version >= OF_VERSION_1_2)) {
Rich Lanea06d0c32013-03-25 08:52:03 -07001685 of_object_u16_set((of_object_t *)obj, %(match_offset)d + 2, 4);
1686 }
1687""" % dict(match_offset=match_offset))
1688 out.write("""
1689 return obj;
1690}
Rich Lanea06d0c32013-03-25 08:52:03 -07001691""" % dict(cls=cls))
1692
1693
Rich Lanea06d0c32013-03-25 08:52:03 -07001694################################################################
1695# Now the top level generator functions
1696################################################################
1697
1698def gen_new_function_declarations(out):
1699 """
1700 Gerenate the header file declarations for new operators for all classes
1701 @param out The file to which to write the decs
1702 """
1703
1704 out.write("""
1705/****************************************************************
1706 *
1707 * New operator declarations
1708 *
1709 * _new: Create a new object for writing; includes init
Rich Lanea06d0c32013-03-25 08:52:03 -07001710 * _init: Initialize and optionally allocate buffer space for an
1711 * automatic instance
1712 *
Rich Lanebb8f17c2014-06-12 13:14:09 -07001713 * _new and requires a delete operation to be called on the object.
Rich Lanea06d0c32013-03-25 08:52:03 -07001714 *
1715 ****************************************************************/
1716""")
Rich Lanea06d0c32013-03-25 08:52:03 -07001717
1718 for cls in of_g.standard_class_order:
1719 out.write("""
1720extern %(cls)s_t *
Rich Lanecd6ef152013-12-15 16:42:18 -08001721 %(cls)s_new(of_version_t version);
Rich Lanea06d0c32013-03-25 08:52:03 -07001722""" % dict(cls=cls))
Rich Lanea06d0c32013-03-25 08:52:03 -07001723 out.write("""extern void %(cls)s_init(
1724 %(cls)s_t *obj, of_version_t version, int bytes, int clean_wire);
1725""" % dict(cls=cls))
1726
1727 out.write("""
1728/****************************************************************
1729 *
1730 * Delete operator static inline definitions.
1731 * These are here for type checking purposes only
1732 *
1733 ****************************************************************/
1734""")
1735 for cls in of_g.standard_class_order:
Rich Lane8841f352014-10-12 19:18:36 -07001736# if type_maps.class_is_inheritance_root(cls):
Rich Lanea06d0c32013-03-25 08:52:03 -07001737# continue
1738 out.write("""
1739/**
1740 * Delete an object of type %(cls)s_t
1741 * @param obj An instance of type %(cls)s_t
1742 *
1743 * \ingroup %(cls)s
1744 */
1745static inline void
1746%(cls)s_delete(%(cls)s_t *obj) {
1747 of_object_delete((of_object_t *)(obj));
1748}
1749""" % dict(cls=cls))
1750
1751 out.write("""
1752typedef void (*of_object_init_f)(of_object_t *obj, of_version_t version,
1753 int bytes, int clean_wire);
Rich Laneb157b0f2013-03-27 13:55:28 -07001754extern const of_object_init_f of_object_init_map[];
Rich Lanea06d0c32013-03-25 08:52:03 -07001755""")
1756
1757 out.write("""
1758/****************************************************************
1759 *
1760 * Function pointer initialization functions
1761 * These are part of the "coerce" type casting for objects
1762 *
1763 ****************************************************************/
1764""")
1765
Rich Laneb604e332013-12-15 13:23:51 -08001766def gen_new_function_definitions(out, cls):
Rich Lanea06d0c32013-03-25 08:52:03 -07001767 """
1768 Generate the new operator for all classes
1769
1770 @param out The file to which to write the functions
1771 """
1772
Rich Laneb604e332013-12-15 13:23:51 -08001773 gen_new_fn_body(cls, out)
1774 gen_init_fn_body(cls, out)
Rich Lanea06d0c32013-03-25 08:52:03 -07001775
Rich Lanea06d0c32013-03-25 08:52:03 -07001776"""
1777Document generation functions
1778
1779The main reason this is here is to generate documentation per
1780accessor that indicates the versions that support the interface.
1781"""
1782
1783
1784def gen_accessor_doc(out, name):
1785 """
1786 Generate documentation for each accessor function that indicates
1787 the versions supporting the accessor.
1788 """
1789
1790 common_top_matter(out, name)
1791
1792 out.write("/* DOCUMENTATION ONLY */\n")
1793
1794 for cls in of_g.standard_class_order:
Rich Lane8841f352014-10-12 19:18:36 -07001795 if type_maps.class_is_inheritance_root(cls):
Rich Lanea06d0c32013-03-25 08:52:03 -07001796 pass # Check this
1797
1798 out.write("""
1799/**
Andreas Wundsam53256162013-05-02 14:05:53 -07001800 * Structure for %(cls)s object. Get/set
Rich Lanea06d0c32013-03-25 08:52:03 -07001801 * accessors available in all versions unless noted otherwise
1802 *
1803""" % dict(cls=cls))
1804 if loxi_utils.class_is_list(cls):
1805 out.write("""\
1806 * @param first Function of type %(cls)s_first_f.
1807 * Setup a TBD class object to the first entry in the list
1808 * @param next Function of type %(cls)s_next_f.
1809 * Advance a TBD class object to the next entry in the list
1810 * @param append_bind Function of type %(cls)s_append_bind_f
1811 * Setup a TBD class object for append to the end of the current list
1812 * @param append Function of type @ref %(cls)s_append_f.
1813 * Copy an item to the end of a list
1814""" % dict(cls=cls))
1815
1816 for m_name in of_g.ordered_members[cls]:
1817 if m_name in of_g.skip_members:
1818 continue
1819 ver_type_map = field_ver_get(cls, m_name)
1820 (m_type, get_rv) = get_acc_rv(cls, m_name)
1821 if len(ver_type_map) == 3:
1822 # ver_string = "Available in all versions"
1823 ver_string = ""
1824 else:
1825 ver_string = "("
1826 for ver in sorted(ver_type_map):
1827 ver_string += " " + of_g.short_version_names[ver]
1828 ver_string += ")."
1829
1830 f_name = acc_name(cls, m_name)
1831 out.write("""\
1832 * @param %(m_name)s_get/set %(ver_string)s
1833 * Accessors for %(m_name)s, a variable of type %(m_type)s. Functions
1834 * are of type %(f_name)s_get_f and _set_f.
1835 *
1836""" % dict(f_name=f_name, m_name=m_name, ver_string=ver_string, m_type=m_type))
1837
1838 out.write("""\
1839 */
1840typedef struct %(cls)s_s %(cls)s_t;
1841""" % dict(cls=cls))
1842
1843 out.write("#endif /* _LOCI_DOC_H_ */\n")