Class: CAS::CLib

Inherits:
Hash
  • Object
show all
Defined in:
lib/Mr.CAS/c-opt.rb

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(name) ⇒ CLib

Returns a new instance of CLib.

Raises:

  • (ArgumentError) 


19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
# File 'lib/Mr.CAS/c-opt.rb', line 19

def initialize(name)
  raise ArgumentError, "Name for the library undefined" unless name.is_a? String
  @name            = name
  @define          = {}
  @include         = {}
  @include[:std]   = []
  @include[:local] = []
  @type            = "double"

  # Default definitions
  # self.define "M_PI", Math::PI
  # self.define "M_INFINITY","HUGE_VAL"
  # self.define "M_E", Math::E
  # self.define "M_EPSILON", 1E-16

  # Default inclusions
  self.include "math.h"
end

Class Method Details

.create(name, &blk) ⇒ Object 



13
14
15
16
17
 
# File 'lib/Mr.CAS/c-opt.rb', line 13

def self.create(name, &blk)
  a = CLib.new(name)
  a.instance_eval(&blk)
  return a
end

Instance Method Details

#as_double ⇒ Object 



38
 
# File 'lib/Mr.CAS/c-opt.rb', line 38

def as_double;   @type = "double";   end

#as_float ⇒ Object 



39
 
# File 'lib/Mr.CAS/c-opt.rb', line 39

def as_float;    @type = "float";    end

#as_int ⇒ Object 



40
 
# File 'lib/Mr.CAS/c-opt.rb', line 40

def as_int;      @type = "int";      end

#as_long_int ⇒ Object 



41
 
# File 'lib/Mr.CAS/c-opt.rb', line 41

def as_long_int; @type = "long int"; end

#define(k, v) ⇒ Object

Raises:

  • (ArgumentError) 


43
44
45
46
47
 
# File 'lib/Mr.CAS/c-opt.rb', line 43

def define(k, v)
  raise ArgumentError, "k must be a String, received a #{k.class}" unless k.is_a? String
  @define[k] = v.to_s
  @define
end

#header ⇒ Object 



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
 
# File 'lib/Mr.CAS/c-opt.rb', line 64

def header
  <<-TO_HEADER
// Header file for library: #{@name}.c

#ifndef #{@name}_H
#define #{@name}_H

// Standard Libraries
#{ @include[:std].map { |e| "#include <#{e}>" }.join("\n") }

// Local Libraries
#{ @include[:local].map { |e| "#include \"#{e}\"" }.join("\n") }

// Definitions
#{ @define.map { |k, v| "#define #{k} #{v}" }.join("\n") }

// Functions
#{
  self.keys.map do |fname|
"#{@type} #{fname}(#{ self[fname].args.map { |x| "#{@type} #{x.name}" }.join(", ")});"
  end.join("\n")
}

#endif // #{@name}_H
  TO_HEADER
end

#implements_as(name, op) ⇒ Object 



62
 
# File 'lib/Mr.CAS/c-opt.rb', line 62

def implements_as(name, op); self[name] = op; end

#include(lib) ⇒ Object 



59
 
# File 'lib/Mr.CAS/c-opt.rb', line 59

def include(lib); self.include_type(:std, lib); end

#include_local(lib) ⇒ Object 



60
 
# File 'lib/Mr.CAS/c-opt.rb', line 60

def include_local(lib); self.include_type(:local, lib); end

#include_type(type, lib) ⇒ Object

Raises:

  • (ArgumentError) 


54
55
56
57
58
 
# File 'lib/Mr.CAS/c-opt.rb', line 54

def include_type(type, lib)
  raise ArgumentError, "type must be a Symbol (:std, :local), received #{type}" unless [:std, :local].include? type
  raise ArgumentError, "lib must be a String, received a #{lib.class}" unless lib.is_a? String
  @include[type] << lib unless @include[type].include? lib
end

#source ⇒ Object 



98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/Mr.CAS/c-opt.rb', line 98

:def]};"}.join("\n")}

  return #{c_op[-1][1][:var]};
}
NEWFUNCTION
    functions << nf
  end

  <<-TO_SOURCE
// Source file for library: #{@name}.c

#include "#{@name}.h"

#{functions.join("\n")}
// end of #{@name}.c
  TO_SOURCE
end

#undefine(k) ⇒ Object 



49
50
51
52
 
# File 'lib/Mr.CAS/c-opt.rb', line 49

def undefine(k)
  @define.delete k
  return @define
end