Class: BinaryParser::StructureDefinition

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

Defined Under Namespace

Classes: DataDefinition, LoopDefinition

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(method_names = [], parent_structure = nil, &init_proc) ⇒ StructureDefinition

Returns a new instance of StructureDefinition.



9
10
11
12
13
14
15
16
 
# File 'lib/structure_definition.rb', line 9

def initialize(method_names=[], parent_structure=nil, &init_proc)
  @method_names = method_names
  @parent_structure = parent_structure
  @bit_at = BitPosition.new     
  @data_def, @var = {}, {}
  @conditions, @names = [], []
  instance_eval(&init_proc) if init_proc
end

Instance Attribute Details

#bit_at ⇒ Object (readonly)

Returns the value of attribute bit_at.



7
8
9
 
# File 'lib/structure_definition.rb', line 7

def bit_at
  @bit_at
end

#names ⇒ Object (readonly)

Returns the value of attribute names.



7
8
9
 
# File 'lib/structure_definition.rb', line 7

def names
  @names
end

#parent_structure ⇒ Object (readonly)

Returns the value of attribute parent_structure.



7
8
9
 
# File 'lib/structure_definition.rb', line 7

def parent_structure
  @parent_structure
end

Instance Method Details

#[](var_name) ⇒ Object 



132
133
134
 
# File 'lib/structure_definition.rb', line 132

def [](var_name)
  return @data_def[var_name]
end

#check_new_def_name(name) ⇒ Object 



68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/structure_definition.rb', line 68

def check_new_def_name(name)
  if name[0..1] == "__"
    raise DefinitionError, "Name that starts with '__' is system-reserved."
  end
  if @method_names.include?(name)
    raise DefinitionError, "Name '#{name}' is already used as method name." +
      "You should chanege to other name."
  end
  if @data_def[name]
    raise DefinitionError, "Name #{name} is already defined." +
      "You should change to other name."
  end
end

#cond(*var_names, &condition_proc) ⇒ Object 



87
88
89
90
91
92
93
94
 
# File 'lib/structure_definition.rb', line 87

def cond(*var_names, &condition_proc)
  var_names.each do |var_name|
    unless name_solvable?(var_name)
      raise DefinitionError, "As condition variable, unsolvable variable #{var_name} is used."
    end
  end
  return Condition.new(*var_names, &condition_proc)
end

#data(name, klass, bit_length) ⇒ Object 



18
19
20
21
22
23
24
25
26
 
# File 'lib/structure_definition.rb', line 18

def data(name, klass, bit_length)
  check_new_def_name(name)
  unless klass.ancestors.include?(TemplateBase)
    raise DefinitionError, "Class #{klass} should be TemplateBase."
  end
  bit_at, bit_length = process_bit_length(bit_length, name)
  @data_def[name] = DataDefinition.new(bit_at, bit_length, @conditions.dup, klass)
  @names << name
end

#IF(condition, &block) ⇒ Object 



62
63
64
65
66
 
# File 'lib/structure_definition.rb', line 62

def IF(condition, &block)
  @conditions.push(condition)
  block.call
  @conditions.pop
end

#len(var_name) ⇒ Object 



116
117
118
119
120
121
122
 
# File 'lib/structure_definition.rb', line 116

def len(var_name)
  unless name_solvable?(var_name)
    raise DefinitionError, "Unsolvable variable #{var_name} is used."
  end
  symbol = ("__LEN__" + var_name.to_s).to_sym
  return Expression.new([symbol])
end

#match(var_name, value) ⇒ Object 



96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/structure_definition.rb', line 96

def match(var_name, value)
  case value
  when Integer
    return cond(var_name){|v| v.to_i == value}
  when String
    return cond(var_name){|v| v.to_s == value}
  when Symbol
    return cond(var_name, value){|v1, v2| v1.to_i == v2.to_i}
  else
    raise DefinitionError, "Unknown type of matching value(#{value}) '#{value.class}'."
  end
end

#name_solvable?(name, structure = self) ⇒ Boolean

Returns:

  • (Boolean) 


82
83
84
85
 
# File 'lib/structure_definition.rb', line 82

def name_solvable?(name, structure=self)
  return structure[name] ||
    (structure.parent_structure && name_solvable?(name, structure.parent_structure))
end

#position ⇒ Object 



124
125
126
 
# File 'lib/structure_definition.rb', line 124

def position
  return Expression.new([:__position])
end

#rest ⇒ Object 



128
129
130
 
# File 'lib/structure_definition.rb', line 128

def rest
  return Expression.new([:__rest])
end

#SPEND(bit_length, name, &block) ⇒ Object 



28
29
30
31
32
33
34
 
# File 'lib/structure_definition.rb', line 28

def SPEND(bit_length, name, &block)
  check_new_def_name(name)
  bit_at, bit_length = process_bit_length(bit_length, name)
  klass = NamelessTemplateMaker.new(self, block)
  @data_def[name] = LoopDefinition.new(bit_at, bit_length, @conditions.dup, klass)
  @names << name
end

#TIMES(times, name, &block) ⇒ Object 



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
 
# File 'lib/structure_definition.rb', line 36

def TIMES(times, name, &block)
  check_new_def_name(name)
  klass = NamelessTemplateMaker.new(self, block)
  structure = klass.structure
  if structure.bit_at.names.empty?
    bit_at, bit_length = process_bit_length(times * structure.bit_at.imm, name)
    @data_def[name] = LoopDefinition.new(bit_at, bit_length, @conditions.dup, klass)
  else
    bit_length = Expression.new([0])
    structure.bit_at.names.each do |bit_at_depending_name|
      depending_length_exp = structure[bit_at_depending_name].bit_length
      depending_length_exp.variables.each do |var_name|
        if structure[var_name]
          raise DefinitionError, "In '#{name}', same level variable #{var_name} is referenced." + 
            "*** TIMES's inner structure's bit-length must be always same." +
            "In other words, that bit-length must not rely on same level variables. ***"
        end
      end
      bit_length += depending_length_exp
    end
    bit_at, bit_length = process_bit_length(bit_length * times, name)
    @data_def[name] = LoopDefinition.new(bit_at, bit_length, @conditions.dup, klass)
  end
  @names << name
end

#var(var_name) ⇒ Object 



109
110
111
112
113
114
 
# File 'lib/structure_definition.rb', line 109

def var(var_name)
  unless name_solvable?(var_name)
    raise DefinitionError, "Unsolvable variable #{var_name} is used."
  end
  return Expression.new([var_name])
end