Class: Efl::EcoreGetopt::REcoreGetopt

Inherits:
Object
  • Object
show all
Defined in:
lib/efl/ecore_getopt.rb

Instance Method Summary collapse

Constructor Details

#initialize(desc) ⇒ REcoreGetopt

Returns a new instance of REcoreGetopt.



94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/efl/ecore_getopt.rb', line 94

def initialize desc
    @pts = []
    @ecore_getopt_st = nil
    @ecore_values_st = nil
    @desc = desc
    @options = [
        [ 0 ],
    ]
    @values = {
        :sentinel0 => [ :pointer, FFI::Pointer::NULL ]
    }
    @values_order = [ :sentinel0 ]
    @types = {
        :string => [ :ecore_getopt_type_str, :strv, :strp ],
        :uchar  => [ :ecore_getopt_type_bool, :boolv, :boolp ],
        :short  => [ :ecore_getopt_type_short, :shortv, :shortp ],
        :int    => [ :ecore_getopt_type_int, :intv, :intp ],
        :long   => [ :ecore_getopt_type_long, :longv, :longp ],
        :ushort => [ :ecore_getopt_type_ushort, :ushortv, :ushortp ],
        :uint   => [ :ecore_getopt_type_uint, :uintv, :uintp ],
        :ulong  => [ :ecore_getopt_type_ulong, :ulongv, :ulongp ],
        :double => [ :ecore_getopt_type_double, :doublev, :doublep ],
        :list   => [ :list, nil, :listp ],
        :pointer=> [ :pointer, nil, :ptrp ],
        :choice => [ :pointer, nil, :ptrp ]
    }
end

Instance Method Details

#[](k) ⇒ Object 



161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
 
# File 'lib/efl/ecore_getopt.rb', line 161

def [] k
    ptype, ptr, sub_type = @values[k.to_s]
    return nil if ptype.nil?
    case ptype
    when:list
        require 'efl/eina_list'
        Efl::EinaList::REinaList.new(ptr.read_pointer).to_a sub_type
    when :choice
        p = ptr.read_pointer
        ( p==FFI::Pointer::NULL ? nil : p.read_string )
    when :string
        p = ptr.read_pointer
        (p==FFI::Pointer::NULL ? nil : p.read_string )
    when :pointer
        ptr.to_ptr
    else
        ptr.send 'read_'+ptype.to_s
    end
end

#append(short, long, help, sub_type, def_val = nil) ⇒ Object 



302
303
304
 
# File 'lib/efl/ecore_getopt.rb', line 302

def append short, long, help, sub_type, def_val=nil
    append_meta short, long, help, FFI::Pointer::NULL, sub_type, def_val
end

#append_meta(short, long, help, meta, sub_type, def_val = nil) ⇒ Object 



288
289
290
291
292
293
294
295
296
297
298
299
300
301
 
# File 'lib/efl/ecore_getopt.rb', line 288

def append_meta short, long, help, meta, sub_type, def_val=nil
    if def_val.nil?
        p = FFI::Pointer::NULL
    else
        p = def_val.inject(FFI::Pointer::NULL) { |list,e|
            ptr = FFI::MemoryPointer.new sub_type
            @pts << ptr
            ptr.send 'write_'+sub_type.to_s, e
            Native.eina_list_append list, ptr
        }
    end
    set_value short, :list, [want_p(p),sub_type]
    set_option [ short, long, help, meta, :ecore_getopt_action_append, [:append,@types[sub_type][0]] ]
end

#callback_args(short, long, help, meta, cb, data, type, def_val) ⇒ Object 



326
327
328
 
# File 'lib/efl/ecore_getopt.rb', line 326

def callback_args short, long, help, meta, cb, data, type, def_val
    callback_full short, long, help, meta, cb, data, true, type, def_val
end

#callback_full(short, long, help, meta, cb, data, arg_req, type, def_val) ⇒ Object 



318
319
320
321
322
 
# File 'lib/efl/ecore_getopt.rb', line 318

def callback_full short, long, help, meta, cb, data, arg_req, type, def_val
    pt, ptr = set_value short, type, def_val
    arg_req = ( arg_req ? :ecore_getopt_desc_arg_requirement_yes : :ecore_getopt_desc_arg_requirement_no )
    set_option [ short, long, help, meta, :ecore_getopt_action_callback, [:callback, [cb, want_p(data), arg_req, ptr ] ] ]
end

#callback_noargs(short, long, help, cb, data = nil) ⇒ Object 



323
324
325
 
# File 'lib/efl/ecore_getopt.rb', line 323

def callback_noargs short, long, help, cb, data=nil
    callback_full short, long, help, FFI::Pointer::NULL, cb, data, false, :uchar, 0
end

#choice(short, long, help, choices) ⇒ Object 



315
316
317
 
# File 'lib/efl/ecore_getopt.rb', line 315

def choice short, long, help, choices
    choice_meta short, long, help, FFI::Pointer::NULL, choices
end

#choice_meta(short, long, help, meta, choices) ⇒ Object 



305
306
307
308
309
310
311
312
313
314
 
# File 'lib/efl/ecore_getopt.rb', line 305

def choice_meta short, long, help, meta, choices
    p = FFI::MemoryPointer.new(:pointer, choices.length+1)
    @pts << p
    choices.each_with_index do |s, i|
            p[i].put_pointer 0, want_p(s)
    end
    p[choices.length].put_pointer 0, FFI::Pointer::NULL
    set_value short, :choice
    set_option [ short, long, help, meta, :ecore_getopt_action_choice, [:choices,p] ]
end

#copyright(short, long, key = nil) ⇒ Object 



250
251
252
253
 
# File 'lib/efl/ecore_getopt.rb', line 250

def copyright short, long, key=nil
    set_value key||short, :uchar, 0
    set_option [ short, long, 'show copyright.', FFI::Pointer::NULL, :ecore_getopt_action_copyright, [:dummy,FFI::Pointer::NULL] ]
end

#count(short, long, help, def_val) ⇒ Object 



284
285
286
287
 
# File 'lib/efl/ecore_getopt.rb', line 284

def count short, long, help, def_val
    set_value short, :int, def_val
    set_option [ short, long, help, FFI::Pointer::NULL, :ecore_getopt_action_count, [:dummy,FFI::Pointer::NULL] ]
end

#create ⇒ Object 



183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
 
# File 'lib/efl/ecore_getopt.rb', line 183

def create
    @ecore_getopt_st = Native::EcoreGetopt.new( FFI::MemoryPointer.new( :uchar, Native::EcoreGetopt.size+Native::EcoreGetoptDesc.size*@options.length) )
    [:prog,:usage,:version,:copyright,:license,:description].each do |sym|
        @ecore_getopt_st[sym] = ( @desc.has_key?(sym) ? FFI::MemoryPointer.from_string(@desc[sym]) : FFI::Pointer::NULL )
    end
    @ecore_getopt_st[:strict] = @desc[:strict] if @desc.has_key? :strict
    @options.each_with_index do |o,i|
        d = @ecore_getopt_st.desc_ptr i
        if o[0]==0
            d[:shortname] = d[:longname] = d[:help] = d[:metavar] = d[:action] = d[:action_param][:dummy] = 0
            break
        end
        d[:shortname] = o[0].to_s.bytes.first
        d[:longname] = want_p o[1]
        d[:help] = want_p o[2]
        d[:metavar] = want_p o[3]
        d[:action] = o[4]
        k, v = o[5]
        case k
        when :dummy
            d[:action_param][:dummy] = v
        when :callback
            cb = d[:action_param][:callback]
            cb[:func] = v[0]
            cb[:data] = v[1]
            cb[:arg_req] = v[2]
            cb[:def] = v[3]
        when :store
            st = d[:action_param][:store]
            st[:type] = v[0]
            st[:arg_req] = v[1]
            st[:def][v[2]] = (v[2]==:strv ?  want_p(v[3]) : v[3] ) unless v[3].nil?
        when :store_const
            d[:action_param][:store_const] = v
        when :choices
            d[:action_param][:choices] = v
        when :append
            d[:action_param][:append_type] = v
        else
            d[:action_param][:dummy] = FFI::Pointer::NULL
        end
    end
    @ecore_values_st = Native::EcoreGetoptValue.new FFI::MemoryPointer.new Native::EcoreGetoptValue, @values_order.length, false
    @values_order.each_with_index do |k,i|
        vtype, vpointer, *sub_type = @values[k]
        vpointer.write_pointer @ecore_getopt_st.desc_ptr(i)[:action_param][:store][:def][:strv] if vtype==:string
        etype, vfield, pfield = @types[vtype]
        @ecore_values_st.value_ptr(i)[pfield] = vpointer
    end
    self
end

#debug ⇒ Object 



330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
 
# File 'lib/efl/ecore_getopt.rb', line 330

def debug
    r = ''
    r << "#{self.class} : #{@ecore_getopt_st.to_ptr}\n"
    [:prog,:usage,:version,:copyright,:license,:description].each do |sym|
        r<< "  #{sym.to_s} : #{@ecore_getopt_st[sym]==FFI::Pointer::NULL ? 'NULL' : @ecore_getopt_st[sym].read_string}\n"
    end
    r << "  strict : #{@ecore_getopt_st[:strict]}\n"
    i=0
    r << "  Descriptions\n"
    while true
        st = @ecore_getopt_st.desc_ptr i
        break if st[:shortname]==0 and st[:longname] == FFI::Pointer::NULL
        r << "    desc #{st.to_ptr}\n"
        r << "     short: #{st[:shortname].chr}\n" unless st[:shortname]==0
        r << "     long:  #{st[:longname].read_string}\n" unless st[:longname]==FFI::Pointer::NULL
        r << "     help:  #{st[:help].read_string}\n" unless st[:help]==FFI::Pointer::NULL
        i+=1
    end
    r << "  Values\n"
    @values_order.each_with_index do |k,i|
        st = @ecore_values_st.value_ptr i
        vtype, vpointer = @values[k]
        etype, vfield, pfield = @types[vtype]
        r << "    value #{st.to_ptr}\n"
        r << "     key:   #{k}\n"
        r << "     type:  #{vtype}\n"
        r << "     value: #{self[k]}\n"
    end
    r
end

#help(short, long, key = nil) ⇒ Object 



242
243
244
245
 
# File 'lib/efl/ecore_getopt.rb', line 242

def help short, long, key=nil
    set_value key||short, :uchar, 0
    set_option [ short, long, 'show this message.', FFI::Pointer::NULL, :ecore_getopt_action_help, [:dummy,FFI::Pointer::NULL] ]
end

#license(short, long, key = nil) ⇒ Object 



254
255
256
257
 
# File 'lib/efl/ecore_getopt.rb', line 254

def license short, long, key=nil
    set_value key||short, :uchar, 0
    set_option [ short, long, 'show license.', FFI::Pointer::NULL, :ecore_getopt_action_license, [:dummy,FFI::Pointer::NULL] ]
end

#parse(argv) ⇒ Object 



234
235
236
237
238
239
240
241
 
# File 'lib/efl/ecore_getopt.rb', line 234

def parse argv
    ptr = FFI::MemoryPointer.new(:pointer, argv.length+1)
    argv.each_with_index do |s, i|
        ptr[i].put_pointer 0, want_p(s)
    end
    ptr[argv.length].put_pointer 0, FFI::Pointer::NULL
    Native.ecore_getopt_parse @ecore_getopt_st, @ecore_values_st, argv.length, ptr
end

#set_option(o) ⇒ Object 



129
130
131
 
# File 'lib/efl/ecore_getopt.rb', line 129

def set_option o
    @options.insert -2, o
end

#set_value(key, ptype, val = nil) ⇒ Object 



132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/efl/ecore_getopt.rb', line 132

def set_value key, ptype, val=nil
    skey = key.to_s
    r = @values[skey]
    if r.nil?
        case ptype
        when :list
            p = FFI::MemoryPointer.new :pointer
            p.write_pointer val[0]
            r = @values[skey] = [ ptype, p, val[1] ]    # add sub_type info
        when :choice
            p = FFI::MemoryPointer.new :pointer
            p.write_pointer FFI::Pointer::NULL
            r = @values[skey] = [ ptype, p ]
        when :string
            p = FFI::MemoryPointer.new :pointer
            p.write_pointer FFI::Pointer::NULL
            r = @values[skey] = [ ptype, p ]
        when :pointer
            r = @values[skey] = [ ptype, val ]
        else
            p = FFI::MemoryPointer.new ptype
            p.send 'write_'+ptype.to_s, val unless val.nil?
            r = @values[skey] = [ ptype, p ]
        end
        @pts << p
    end
    @values_order.insert -2, skey
    r
end

#store(short, long, help, type, def_val = nil) ⇒ Object 



263
264
265
 
# File 'lib/efl/ecore_getopt.rb', line 263

def store short, long, help, type, def_val=nil
    store_full short, long, help, FFI::Pointer::NULL, :ecore_getopt_desc_arg_requirement_yes, type, def_val
end

#store_const(short, long, help, def_val, value) ⇒ Object 



272
273
274
275
 
# File 'lib/efl/ecore_getopt.rb', line 272

def store_const short, long, help, def_val, value
    set_value short, :int, def_val
    set_option [ short, long, help, FFI::Pointer::NULL, :ecore_getopt_action_store_const, [:store_const, value] ]
end

#store_def(short, long, help, type, def_val) ⇒ Object 



269
270
271
 
# File 'lib/efl/ecore_getopt.rb', line 269

def store_def short, long, help, type, def_val
    store_full short, long, help, FFI::Pointer::NULL, :ecore_getopt_desc_arg_requirement_optional, type, def_val
end

#store_false(short, long, help) ⇒ Object 



280
281
282
283
 
# File 'lib/efl/ecore_getopt.rb', line 280

def store_false short, long, help
    set_value short, :uchar, 1
    set_option [ short, long, help, FFI::Pointer::NULL, :ecore_getopt_action_store_false, [:dummy,FFI::MemoryPointer::NULL] ]
end

#store_full(short, long, help, meta, arg_req, type, def_val) ⇒ Object 



258
259
260
261
262
 
# File 'lib/efl/ecore_getopt.rb', line 258

def store_full short, long, help, meta, arg_req, type, def_val
    vtype, vpointer = set_value short, type, def_val
    etype, vfield, pfield = @types[vtype]
    set_option [ short, long, help, meta, :ecore_getopt_action_store, [:store, [etype, arg_req, vfield, def_val] ] ]
end

#store_meta(short, long, help, meta, type, def_val = nil) ⇒ Object 



266
267
268
 
# File 'lib/efl/ecore_getopt.rb', line 266

def store_meta short, long, help, meta, type, def_val=nil
    store_full short, long, help, meta, :ecore_getopt_desc_arg_requirement_yes, type, def_val
end

#store_true(short, long, help) ⇒ Object 



276
277
278
279
 
# File 'lib/efl/ecore_getopt.rb', line 276

def store_true short, long, help
    set_value short, :uchar, 0
    set_option [ short, long, help, FFI::Pointer::NULL, :ecore_getopt_action_store_true, [:dummy,FFI::MemoryPointer::NULL] ]
end

#to_ptr ⇒ Object 



180
181
182
 
# File 'lib/efl/ecore_getopt.rb', line 180

def to_ptr
    ( @ecore_getopt_st.nil? ? nil : @ecore_getopt_st.to_ptr )
end

#version(short, long, key = nil) ⇒ Object 



246
247
248
249
 
# File 'lib/efl/ecore_getopt.rb', line 246

def version short, long, key=nil
    set_value key||short, :uchar, 0
    set_option [ short, long, 'show program version.', FFI::Pointer::NULL, :ecore_getopt_action_version, [:dummy,FFI::Pointer::NULL] ]
end