FilesExpand file tree

rc/3.23

/

trapgen.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

executable file

·

103 lines (81 loc) · 2.84 KB

rc/3.23

/

trapgen.py

Copy path

Top

File metadata and controls

• Code
• Blame

executable file

·

103 lines (81 loc) · 2.84 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

"""

C++ trap entry generation

`generate(opts, renderer)` will generate `TrapTags.h` (for types of labels) and `TrapEntries.h` (for trap emission) out

of a dbscheme file.

Each table in the `dbscheme` gets a corresponding `struct` defined in `TrapEntries.h` with a field for each column and

an appropriate streaming operator for the trap emission.

Unions in the `dbscheme` are used to populate a hierarchy of tags (empty structs) in `TrapTags.h` that is used to

enforce a type system on trap labels (see `TrapLabel.h`).

"""

import logging

import pathlib

import inflection

from toposort import toposort_flatten

from misc.codegen.lib import dbscheme, cpp

from misc.codegen.loaders import dbschemeloader

log = logging.getLogger(__name__)

def get_tag_name(s):

assert s.startswith("@")

return inflection.camelize(s[1:])

def get_cpp_type(schema_type: str):

if schema_type.startswith("@"):

tag = get_tag_name(schema_type)

return f"TrapLabel<{tag}Tag>"

if schema_type == "string":

return "std::string"

if schema_type == "boolean":

return "bool"

return schema_type

def get_field(c: dbscheme.Column):

args = {

"field_name": c.schema_name,

"base_type": c.type,

}

args.update(cpp.get_field_override(c.schema_name))

args["base_type"] = get_cpp_type(args["base_type"])

return cpp.Field(**args)

def get_binding_column(t: dbscheme.Table):

try:

return next(c for c in t.columns if c.binding)

except StopIteration:

return None

def get_trap(t: dbscheme.Table):

id = get_binding_column(t)

if id:

id = get_field(id)

return cpp.Trap(

table_name=t.name,

name=inflection.camelize(t.name),

fields=[get_field(c) for c in t.columns],

id=id,

)

def generate(opts, renderer):

assert opts.cpp_output

tag_graph = {}

out = opts.cpp_output

trap_library = opts.trap_library

traps = {pathlib.Path(): []}

for e in dbschemeloader.iterload(opts.dbscheme):

if e.is_table:

traps.setdefault(e.dir, []).append(get_trap(e))

elif e.is_union:

tag_graph.setdefault(e.lhs, set())

for d in e.rhs:

tag_graph.setdefault(d.type, set()).add(e.lhs)

for dir, entries in traps.items():

dir = dir or pathlib.Path()

relative_gen_dir = pathlib.Path(*[".." for _ in dir.parents])

renderer.render(

cpp.TrapList(entries, opts.dbscheme, trap_library, relative_gen_dir),

out / dir / "TrapEntries",

)

tags = []

for tag in toposort_flatten(tag_graph):

tags.append(

cpp.Tag(

name=get_tag_name(tag),

bases=[get_tag_name(b) for b in sorted(tag_graph[tag])],

id=tag,

)

)

renderer.render(cpp.TagList(tags, opts.dbscheme), out / "TrapTags")