|
| 1 | +# frozen_string_literal: true |
| 2 | +module Fiddle |
| 3 | + # A mixin that provides methods for parsing C struct and prototype signatures. |
| 4 | + # |
| 5 | + # == Example |
| 6 | + # require 'fiddle/import' |
| 7 | + # |
| 8 | + # include Fiddle::CParser |
| 9 | + # #=> Object |
| 10 | + # |
| 11 | + # parse_ctype('int') |
| 12 | + # #=> Fiddle::TYPE_INT |
| 13 | + # |
| 14 | + # parse_struct_signature(['int i', 'char c']) |
| 15 | + # #=> [[Fiddle::TYPE_INT, Fiddle::TYPE_CHAR], ["i", "c"]] |
| 16 | + # |
| 17 | + # parse_signature('double sum(double, double)') |
| 18 | + # #=> ["sum", Fiddle::TYPE_DOUBLE, [Fiddle::TYPE_DOUBLE, Fiddle::TYPE_DOUBLE]] |
| 19 | + # |
| 20 | + module CParser |
| 21 | + # Parses a C struct's members |
| 22 | + # |
| 23 | + # Example: |
| 24 | + # require 'fiddle/import' |
| 25 | + # |
| 26 | + # include Fiddle::CParser |
| 27 | + # #=> Object |
| 28 | + # |
| 29 | + # parse_struct_signature(['int i', 'char c']) |
| 30 | + # #=> [[Fiddle::TYPE_INT, Fiddle::TYPE_CHAR], ["i", "c"]] |
| 31 | + # |
| 32 | + # parse_struct_signature(['char buffer[80]']) |
| 33 | + # #=> [[[Fiddle::TYPE_CHAR, 80]], ["buffer"]] |
| 34 | + # |
| 35 | + def parse_struct_signature(signature, tymap=nil) |
| 36 | + if signature.is_a?(String) |
| 37 | + signature = split_arguments(signature, /[,;]/) |
| 38 | + end |
| 39 | + mems = [] |
| 40 | + tys = [] |
| 41 | + signature.each{|msig| |
| 42 | + msig = compact(msig) |
| 43 | + case msig |
| 44 | + when /^[\w\*\s]+[\*\s](\w+)$/ |
| 45 | + mems.push($1) |
| 46 | + tys.push(parse_ctype(msig, tymap)) |
| 47 | + when /^[\w\*\s]+\(\*(\w+)\)\(.*?\)$/ |
| 48 | + mems.push($1) |
| 49 | + tys.push(parse_ctype(msig, tymap)) |
| 50 | + when /^([\w\*\s]+[\*\s])(\w+)\[(\d+)\]$/ |
| 51 | + mems.push($2) |
| 52 | + tys.push([parse_ctype($1.strip, tymap), $3.to_i]) |
| 53 | + when /^([\w\*\s]+)\[(\d+)\](\w+)$/ |
| 54 | + mems.push($3) |
| 55 | + tys.push([parse_ctype($1.strip, tymap), $2.to_i]) |
| 56 | + else |
| 57 | + raise(RuntimeError,"can't parse the struct member: #{msig}") |
| 58 | + end |
| 59 | + } |
| 60 | + return tys, mems |
| 61 | + end |
| 62 | + |
| 63 | + # Parses a C prototype signature |
| 64 | + # |
| 65 | + # If Hash +tymap+ is provided, the return value and the arguments from the |
| 66 | + # +signature+ are expected to be keys, and the value will be the C type to |
| 67 | + # be looked up. |
| 68 | + # |
| 69 | + # Example: |
| 70 | + # require 'fiddle/import' |
| 71 | + # |
| 72 | + # include Fiddle::CParser |
| 73 | + # #=> Object |
| 74 | + # |
| 75 | + # parse_signature('double sum(double, double)') |
| 76 | + # #=> ["sum", Fiddle::TYPE_DOUBLE, [Fiddle::TYPE_DOUBLE, Fiddle::TYPE_DOUBLE]] |
| 77 | + # |
| 78 | + # parse_signature('void update(void (*cb)(int code))') |
| 79 | + # #=> ["update", Fiddle::TYPE_VOID, [Fiddle::TYPE_VOIDP]] |
| 80 | + # |
| 81 | + # parse_signature('char (*getbuffer(void))[80]') |
| 82 | + # #=> ["getbuffer", Fiddle::TYPE_VOIDP, []] |
| 83 | + # |
| 84 | + def parse_signature(signature, tymap=nil) |
| 85 | + tymap ||= {} |
| 86 | + case compact(signature) |
| 87 | + when /^(?:[\w\*\s]+)\(\*(\w+)\((.*?)\)\)(?:\[\w*\]|\(.*?\));?$/ |
| 88 | + func, args = $1, $2 |
| 89 | + return [func, TYPE_VOIDP, split_arguments(args).collect {|arg| parse_ctype(arg, tymap)}] |
| 90 | + when /^([\w\*\s]+[\*\s])(\w+)\((.*?)\);?$/ |
| 91 | + ret, func, args = $1.strip, $2, $3 |
| 92 | + return [func, parse_ctype(ret, tymap), split_arguments(args).collect {|arg| parse_ctype(arg, tymap)}] |
| 93 | + else |
| 94 | + raise(RuntimeError,"can't parse the function prototype: #{signature}") |
| 95 | + end |
| 96 | + end |
| 97 | + |
| 98 | + # Given a String of C type +ty+, returns the corresponding Fiddle constant. |
| 99 | + # |
| 100 | + # +ty+ can also accept an Array of C type Strings, and will be returned in |
| 101 | + # a corresponding Array. |
| 102 | + # |
| 103 | + # If Hash +tymap+ is provided, +ty+ is expected to be the key, and the |
| 104 | + # value will be the C type to be looked up. |
| 105 | + # |
| 106 | + # Example: |
| 107 | + # require 'fiddle/import' |
| 108 | + # |
| 109 | + # include Fiddle::CParser |
| 110 | + # #=> Object |
| 111 | + # |
| 112 | + # parse_ctype('int') |
| 113 | + # #=> Fiddle::TYPE_INT |
| 114 | + # |
| 115 | + # parse_ctype('double diff') |
| 116 | + # #=> Fiddle::TYPE_DOUBLE |
| 117 | + # |
| 118 | + # parse_ctype('unsigned char byte') |
| 119 | + # #=> -Fiddle::TYPE_CHAR |
| 120 | + # |
| 121 | + # parse_ctype('const char* const argv[]') |
| 122 | + # #=> -Fiddle::TYPE_VOIDP |
| 123 | + # |
| 124 | + def parse_ctype(ty, tymap=nil) |
| 125 | + tymap ||= {} |
| 126 | + case ty |
| 127 | + when Array |
| 128 | + return [parse_ctype(ty[0], tymap), ty[1]] |
| 129 | + when 'void' |
| 130 | + return TYPE_VOID |
| 131 | + when /^(?:(?:signed\s+)?long\s+long(?:\s+int\s+)?|int64_t)(?:\s+\w+)?$/ |
| 132 | + if( defined?(TYPE_LONG_LONG) ) |
| 133 | + return TYPE_LONG_LONG |
| 134 | + else |
| 135 | + raise(RuntimeError, "unsupported type: #{ty}") |
| 136 | + end |
| 137 | + when /^(?:unsigned\s+long\s+long(?:\s+int\s+)?|uint64_t)(?:\s+\w+)?$/ |
| 138 | + if( defined?(TYPE_LONG_LONG) ) |
| 139 | + return -TYPE_LONG_LONG |
| 140 | + else |
| 141 | + raise(RuntimeError, "unsupported type: #{ty}") |
| 142 | + end |
| 143 | + when /^(?:signed\s+)?long(?:\s+int\s+)?(?:\s+\w+)?$/ |
| 144 | + return TYPE_LONG |
| 145 | + when /^unsigned\s+long(?:\s+int\s+)?(?:\s+\w+)?$/ |
| 146 | + return -TYPE_LONG |
| 147 | + when /^(?:signed\s+)?int(?:\s+\w+)?$/ |
| 148 | + return TYPE_INT |
| 149 | + when /^(?:unsigned\s+int|uint)(?:\s+\w+)?$/ |
| 150 | + return -TYPE_INT |
| 151 | + when /^(?:signed\s+)?short(?:\s+int\s+)?(?:\s+\w+)?$/ |
| 152 | + return TYPE_SHORT |
| 153 | + when /^unsigned\s+short(?:\s+int\s+)?(?:\s+\w+)?$/ |
| 154 | + return -TYPE_SHORT |
| 155 | + when /^(?:signed\s+)?char(?:\s+\w+)?$/ |
| 156 | + return TYPE_CHAR |
| 157 | + when /^unsigned\s+char(?:\s+\w+)?$/ |
| 158 | + return -TYPE_CHAR |
| 159 | + when /^float(?:\s+\w+)?$/ |
| 160 | + return TYPE_FLOAT |
| 161 | + when /^double(?:\s+\w+)?$/ |
| 162 | + return TYPE_DOUBLE |
| 163 | + when /^size_t(?:\s+\w+)?$/ |
| 164 | + return TYPE_SIZE_T |
| 165 | + when /^ssize_t(?:\s+\w+)?$/ |
| 166 | + return TYPE_SSIZE_T |
| 167 | + when /^ptrdiff_t(?:\s+\w+)?$/ |
| 168 | + return TYPE_PTRDIFF_T |
| 169 | + when /^intptr_t(?:\s+\w+)?$/ |
| 170 | + return TYPE_INTPTR_T |
| 171 | + when /^uintptr_t(?:\s+\w+)?$/ |
| 172 | + return TYPE_UINTPTR_T |
| 173 | + when /\*/, /\[[\s\d]*\]/ |
| 174 | + return TYPE_VOIDP |
| 175 | + else |
| 176 | + ty = ty.split(' ', 2)[0] |
| 177 | + if( tymap[ty] ) |
| 178 | + return parse_ctype(tymap[ty], tymap) |
| 179 | + else |
| 180 | + raise(DLError, "unknown type: #{ty}") |
| 181 | + end |
| 182 | + end |
| 183 | + end |
| 184 | + |
| 185 | + private |
| 186 | + |
| 187 | + def split_arguments(arguments, sep=',') |
| 188 | + return [] if arguments.strip == 'void' |
| 189 | + arguments.scan(/([\w\*\s]+\(\*\w*\)\(.*?\)|[\w\*\s\[\]]+)(?:#{sep}\s*|$)/).collect {|m| m[0]} |
| 190 | + end |
| 191 | + |
| 192 | + def compact(signature) |
| 193 | + signature.gsub(/\s+/, ' ').gsub(/\s*([\(\)\[\]\*,;])\s*/, '\1').strip |
| 194 | + end |
| 195 | + |
| 196 | + end |
| 197 | +end |
0 commit comments