Class: Expression

Inherits:
Node show all
Defined in:
lib/tecsgen/core/expression.rb

Overview

TECS Generator

   Generator for TOPPERS Embedded Component System

Copyright (C) 2008-2017 by TOPPERS Project

–

上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
(1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
    権表示，この利用条件および下記の無保証規定が，そのままの形でソー
    スコード中に含まれていること．
(2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
    用できる形で再配布する場合には，再配布に伴うドキュメント（利用
    者マニュアルなど）に，上記の著作権表示，この利用条件および下記
    の無保証規定を掲載すること．
(3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
    用できない形で再配布する場合には，次のいずれかの条件を満たすこ
    と．
  (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
      作権表示，この利用条件および下記の無保証規定を掲載すること．
  (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
      報告すること．
(4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
    害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
    また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
    由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
    免責すること．

本ソフトウェアは，無保証で提供されているものである．上記著作権者お
よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
の責任を負わない．

$Id: expression.rb 2633 2017-04-02 06:02:05Z okuma-top $

++

Constant Summary collapse

MAX_NEST_LEVEL =

定数式(elements)を評価する

このメソッドは Expression クラスのメソッドである必要はない（関数化できる）

elements は式の要素

name_list, name_list2 は eval_const を参照

RETURN: 評価した定数、評価できなかった場合は nil を返す

64

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Node

#cdl_error, #cdl_error2, #cdl_error3, #cdl_info, #cdl_info2, #cdl_warning, #cdl_warning2, #get_locale, #locale_str, #set_locale

Constructor Details

#initialize(elements, locale = nil) ⇒ Expression

@elements # array



42
43
44
45
46
47
48
49
 
# File 'lib/tecsgen/core/expression.rb', line 42

def initialize(elements, locale = nil)
  super()
  if locale
    @locale = locale
  end

  @elements = elements
end

Class Method Details

.create_cell_join_expression(nsp, subscript, port_name, locale = nil) ⇒ Object

Expression# セルへの結合の式を生成する

nsp

NamespacePath

subscript

Integer

port_name

Symbol

analyze_cell_join_expression と対になっている



910
911
912
913
914
915
916
917
918
919
920
921
922
923
 
# File 'lib/tecsgen/core/expression.rb', line 910

def self.create_cell_join_expression(nsp, subscript, port_name, locale = nil)
  if !port_name.instance_of?(Symbol)
    raise "port_name: not Symbol"
  end

  if subscript
    elements = [:OP_SUBSC, [:OP_DOT, [:IDENTIFIER, nsp],
                              Token.new(port_name, nil, nil, nil)],
                 Expression.create_integer_constant(subscript, @locale)]
  else
    elements = [:OP_DOT, [:IDENTIFIER, nsp], Token.new(port_name, nil, nil, nil)]
  end
  return Expression.new(elements, locale)
end

.create_integer_constant(val, locale = nil) ⇒ Object

Expression#整数定数の式を生成する

val

Integer : 値： 整数



927
928
929
930
931
932
 
# File 'lib/tecsgen/core/expression.rb', line 927

def self.create_integer_constant(val, locale = nil)
  if val != Integer(val) || val < 0
    raise "create_integer_constant: not integer or negative: #{val}"
  end
  Expression.new([:INTEGER_CONSTANT, Token.new(val, nil, nil, nil)], locale)
end

.create_single_identifier(nsp, locale) ⇒ Object

Expression#

nsp

NamespacePath : 参照するもの識別子



949
950
951
952
953
954
 
# File 'lib/tecsgen/core/expression.rb', line 949

def self.create_single_identifier(nsp, locale)
  if !nsp.instance_of?(NamespacePath)
    raise "create_single_identifier: not NamespacePath: #{nsp}"
  end
  Expression.new([:IDENTIFIER, nsp])
end

Instance Method Details

#analyze_cell_join_expression ⇒ Object

Expression#セル結合の式を解析する

Cell.eEntry => [ :OP_DOT, [ :IDENTIFIER, token ], token ] Cell.eEntry => [ :OP_SUBSC, [ :OP_DOT, [ :IDENTIFIER, token ], token ], expression ] Return: [ NamespacePath(cell_name), Integer(subscript) or nil, Token(port_name)]



883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
 
# File 'lib/tecsgen/core/expression.rb', line 883

def analyze_cell_join_expression
  # 右辺の Expression の要素を取り出す
  elements = @elements
  if elements[0] == :OP_SUBSC # 右辺：受け口配列？
    # elements = [ :OP_SUBSC, [ :OP_DOT, [ :IDENTIFIER, token ], token ], expression ]
    subscript = elements[2].eval_const(nil) # 受け口配列の添数
    elements  = elements[1] # mikan 配列だった場合
  else
    subscript = nil
  end

  # elements = [ :OP_DOT, [ :IDENTIFIER, token ], token ]
  if elements[0] != :OP_DOT || elements[1][0] != :IDENTIFIER # 1
    return nil
  end

  nsp = elements[1][1] # NamespacePath
  port_name = elements[2].val

  return [nsp, subscript, port_name]
end

#analyze_single_identifier ⇒ Object

Expression#単一の識別子の式を解析する

Identifier => [ :IDENTIFIER, token ] Return: NamespacePath(Identifier)



937
938
939
940
941
942
943
944
945
 
# File 'lib/tecsgen/core/expression.rb', line 937

def analyze_single_identifier
  # 右辺の Expression の要素を取り出す
  elements = @elements
  if elements[0] == :IDENTIFIER
    return elements[1]
  else
    return nil
  end
end

#check_dir_for_param(namedList, dir, spec) ⇒ Object 



125
126
127
 
# File 'lib/tecsgen/core/expression.rb', line 125

def check_dir_for_param(namedList, dir, spec)
  elements_check_dir_for_param(@elements, namedList, dir, spec)
end

#clone_elements(elements) ⇒ Object

Expression#elements のクローンを作成 elements::Array このメソッドは、Array のディープコピーを行う



863
864
865
866
867
868
869
870
871
872
873
 
# File 'lib/tecsgen/core/expression.rb', line 863

def clone_elements(elements)
  elements = elements.clone
  elements.map!{|ele|
    if ele.instance_of? Array
      clone_elements ele
    else
      ele
    end
  }
  return elements
end

#clone_for_composite ⇒ Object

Expression#Expression のクローンを作成する



853
854
855
856
857
858
 
# File 'lib/tecsgen/core/expression.rb', line 853

def clone_for_composite
  cl = self.clone
  elements = clone_elements @elements
  cl.set_elements elements
  return cl
end

#elements_check_dir_for_param(elements, namedList, dir, spec) ⇒ Object

式が size_is, count_is, string の引数である場合の方向のチェック



744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
 
# File 'lib/tecsgen/core/expression.rb', line 744

def elements_check_dir_for_param(elements, namedList, dir, spec)
 # dir ： 元の引数の方向
 # direct: size_is などの引数の変数の方向

  case elements[0]
  when :IDENTIFIER
    nsp = elements[1]
    if nsp.is_name_only?
      paramdecl = namedList.get_item(nsp.get_name)
    else
      paramdecl = nil
    end

    return unless paramdecl # if nil already error in element_get_type

    direct = paramdecl.get_direction
    judge = false
    case spec
    when "size_is", "string"
      case dir
      when :IN, :OUT, :INOUT, :SEND
        judge = true if direct == :IN || direct == :INOUT
        req_direct = "in or inout"
      when :RECEIVE
        judge = true if direct == :OUT || direct == :INOUT
        req_direct = "out or inout"
      end

    when "count_is"
      case dir
      when :IN, :SEND
        judge = true if direct == :IN || direct == :INOUT
        req_direct = "in or inout"
      when :OUT, :RECEIVE # mikan out で count_is のみ指定されている場合 in でなくてはならない
        judge = true if direct == :OUT || direct == :INOUT
        req_direct = "out or inout"
      when :INOUT
        judge = true if direct == :INOUT
        req_direct = "inout"
      end
    end

    if judge == false
      cdl_error("E1015 \'$1\': direction mismatch for $2, $3 required", nsp.get_path_str, spec, req_direct)
    end

  when :INTEGER_CONSTANT, :FLOATING_CONSTANT, :OCTAL_CONSTANT, :HEX_CONSTANT, :CHARACTER_LITERAL, :STRING_LITERAL_LIST
    return true

  # 単項演算子
  when :OP_U_ASTER, :OP_SIZEOF_EXPR, :OP_SIZEOF_TYPE, :OP_U_PLUS, :OP_U_MINUS, :OP_U_TILDE, :OP_U_EXCLAM, :CAST, :OP_U_AMP, :PARENTHESES,
    elements_check_dir_for_param(elements[1], namedList, dir, spec)

  # 2項演算子
  when :OP_SUBSC, :OP_DOT, :OP_REF, :OP_MULT, :OP_DIV, :OP_REMAIN, :OP_ADD, :OP_SUB, :OP_LSFT, :OP_RSFT, :OP_LT, :OP_GT, :OP_LE, :OP_GE, :OP_EQ, :OP_NE, :OP_AND, :OP_EOR, :OP_OR, :OP_LAND, :OP_LOR
    return elements_check_dir_for_param(elements[1], namedList, dir, spec) && elements_check_dir_for_param(elements[2], namedList, dir, spec)

  # 3項演算子
  when :OP_CEX
    return elements_check_dir_for_param(elements[1], namedList, dir, spec) && elements_check_dir_for_param(elements[2], namedList, dir, spec) && elements_check_dir_for_param(elements[3], namedList, dir, spec)

  else
    cdl_error("E1016 $1: elements_check_dir_for_param: sorry not supported", elements[0])
  end
end

#elements_get_type_sub(elements, namedList) ⇒ Object 



682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
 
# File 'lib/tecsgen/core/expression.rb', line 682

def elements_get_type_sub(elements, namedList)
  case elements[0]
  when :IDENTIFIER
    nsp = elements[1]
    if nsp.is_name_only?
      paramdecl = namedList.get_item(nsp.get_name)
    else
      paramdecl = nil
    end
    unless paramdecl
      cdl_error("E1012 $1: not found in parameter list", nsp.get_path_str)
      return IntType.new(32) # dummy result
    end
    return paramdecl.get_type
# mikan get_type
#    when :INTEGER_CONSTANT
#    when :FLOATING_CONSTANT
#    when :OCTAL_CONSTANT
#    when :HEX_CONSTANT
#    when :CHARACTER_LITERAL
#    when :STRING_LITERAL_LIST
#    when :PARENTHESES
#    when :OP_SUBSC
#    when :OP_DOT
#    when :OP_REF
#    when :OP_SIZEOF_EXPR
#    when :OP_SIZEOF_TYPE
#    when :OP_U_AMP
  when :OP_U_ASTER
    type = elements_get_type(elements[1], namedList)
    unless type.is_a?(PtrType)
      cdl_error("E1013 \'*\': operand is not pointer value")
      return IntType.new(8) # IntType を返しておく
    end
    return type.get_referto

  when :OP_U_PLUS, :OP_U_MINUS
    # mikan operand が適切な型かチェックしていない
    return elements_get_type(elements[1], namedList)

  when :OP_ADD, :OP_SUB, :OP_MULT, :OP_DIV, :OP_REMAIN
    # mikan operand が適切な型かチェックしていない＆左辺の型を採用している
    return elements_get_type(elements[1], namedList)

  when :OP_U_TILDE
    # mikan operand が整数かチェックしていない
    return elements_get_type(elements[1], namedList)
  when :OP_AND, :OP_EOR, :OP_OR, :OP_LSFT, :OP_RSFT
    # mikan operand が整数かチェックしていない
    return BoolType.new
  when :OP_U_EXCLAM
    # mikan operand が整数かチェックしていない
    return BoolType.new

  when :OP_LT, :OP_GT, :OP_LE, :OP_GE, :OP_EQ, :OP_NE, :OP_LAND, :OP_LOR, :OP_CEX, :CAST
    cdl_error("E1014 $1: elements_get_type: sorry not supported", elements[0])
  end

  return nil
end

#elements_rpn(elements, name_list = nil, name_list2 = nil) ⇒ Object

Expression# 逆ポーランド文字列化 (private)

name_list

ParamlList 関数の引数リスト



239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
 
# File 'lib/tecsgen/core/expression.rb', line 239

def elements_rpn(elements, name_list = nil, name_list2 = nil)
  if elements.instance_of? Token
    print "rpn: #{elements}\n"
    return elements.to_s # OP_DOT, OP_REF の右辺
  end

  case elements[0]
  when :IDENTIFIER
    nsp = elements[1]
    # if nsp.is_name_only? && name_list && name_list.find( nsp.get_name ) then
    if nsp.is_name_only?
      count = 0
      # p "search: #{nsp.get_name}"
      name_list.get_items.each{|nm, val|
        # p "    : #{nm.get_name} #{nsp.get_name.class} #{nm.get_name.class}"
        if nsp.get_name == nm.get_name
          return " $#{count}"
        end
        count += 1
      }
      raise "not found parameter"
    else
      # return  elements[1].get_global_name
      raise "not unexpected parameter"
    end
  when :INTEGER_CONSTANT, :FLOATING_CONSTANT, :OCTAL_CONSTANT, :HEX_CONSTANT, :CHARACTER_LITERAL, :STRING_LITERAL_LIST, :BOOL_CONSTANT
    return elements[1].to_s
  when :PARENTHESES
    return elements_rpn(elements[1], name_list, name_list2)
  when :OP_SUBSC
    return elements_rpn(elements[1], name_list, name_list2) + " " + elements_rpn(elements[1], "", name_list, name_list2) + " []"
  when :OP_DOT
    return elements_rpn(elements[1], name_list, name_list2) + " ."
  when :OP_REF
    return elements_rpn(elements[1], name_list, name_list2) + " ->"
  when :OP_SIZEOF_EXPR
    return elements_rpn(elements[1], name_list, name_list2) + " #s"
  when :OP_SIZEOF_TYPE
    return elements_rpn(elements[1], name_list, name_list2) + " #S"
  when :OP_U_AMP
    return elements_rpn(elements[1], name_list, name_list2) + " #&"
  when :OP_U_ASTER
    return elements_rpn(elements[1], name_list, name_list2) + " #*"
  when :OP_U_PLUS
    return elements_rpn(elements[1], name_list, name_list2) + " #+"
  when :OP_U_MINUS
    return elements_rpn(elements[1], name_list, name_list2) + " #-"
  when :OP_U_TILDE
    return elements_rpn(elements[1], name_list, name_list2) + " #~"
  when :OP_U_EXCLAM
    return elements_rpn(elements[1], name_list, name_list2) + " #!"
  when :CAST
    return elements_rpn(elements[1], name_list, name_list2) + " #(" + elements_rpn(elements[2], "", name_list, name_list2) + ")"
  when :OP_MULT
    return elements_rpn(elements[1], name_list, name_list2) + " " + elements_rpn(elements[2], "", name_list, name_list2) + " *"
  when :OP_DIV
    return elements_rpn(elements[1], name_list, name_list2) + " " + elements_rpn(elements[2], "", name_list, name_list2) + " /"
  when :OP_REMAIN
    return elements_rpn(elements[1], name_list, name_list2) + " " + elements_rpn(elements[2], "", name_list, name_list2) + " %"
  when :OP_ADD
    return elements_rpn(elements[1], name_list, name_list2) + " " + elements_rpn(elements[2], "", name_list, name_list2) + " +"
  when :OP_SUB
    return elements_rpn(elements[1], name_list, name_list2) + " " + elements_rpn(elements[2], "", name_list, name_list2) + " -"
  when :OP_LSFT
    return elements_rpn(elements[1], name_list, name_list2) + " " + elements_rpn(elements[2], "", name_list, name_list2) + " <<"
  when :OP_RSFT
    return elements_rpn(elements[1], name_list, name_list2) + " " + elements_rpn(elements[2], "", name_list, name_list2) + " >>"
  when :OP_LT
    return elements_rpn(elements[1], name_list, name_list2) + " " + elements_rpn(elements[2], "", name_list, name_list2) + " <"
  when :OP_GT
    return elements_rpn(elements[1], name_list, name_list2) + " " + elements_rpn(elements[2], "", name_list, name_list2) + " >"
  when :OP_LE
    return elements_rpn(elements[1], name_list, name_list2) + " " + elements_rpn(elements[2], "", name_list, name_list2) + " <="
  when :OP_GE
    return elements_rpn(elements[1], name_list, name_list2) + " " + elements_rpn(elements[2], "", name_list, name_list2) + " >="
  when :OP_EQ
    return elements_rpn(elements[1], name_list, name_list2) + " " + elements_rpn(elements[2], "", name_list, name_list2) + " =="
  when :OP_NE
    return elements_rpn(elements[1], name_list, name_list2) + " " + elements_rpn(elements[2], "", name_list, name_list2) + " !="
  when :OP_AND
    return elements_rpn(elements[1], name_list, name_list2) + " " + elements_rpn(elements[2], "", name_list, name_list2) + " &"
  when :OP_EOR
    return elements_rpn(elements[1], name_list, name_list2) + " " + elements_rpn(elements[2], "", name_list, name_list2) + " ^"
  when :OP_OR
    return elements_rpn(elements[1], name_list, name_list2) + " " + elements_rpn(elements[2], "", name_list, name_list2) + " |"
  when :OP_LAND
    return elements_rpn(elements[1], name_list, name_list2) + " " + elements_rpn(elements[2], "", name_list, name_list2) + " &&"
  when :OP_LOR
    return elements_rpn(elements[1], name_list, name_list2) + " " + elements_rpn(elements[2], "", name_list, name_list2) + " ||"
  when :OP_CEX
    return elements_rpn(elements[1], name_list, name_list2) + " " +
           elements_rpn(elements[2], name_list, name_list2) + " " +
           elements_rpn(elements[3], name_list, name_list2) + " ?:"
  else
    raise "Unknown expression element: #{elemets[0]}. try -t and please report"
  end
  return ""
end

#eval_const(name_list, name_list2 = nil) ⇒ Object

定数式として評価する(トライしてみる)

このメソッドは、定数式を評価する ・attribute, var の初期化子 ・size_is, count_is 引数 ・配列の添数

name_list(NamedList|Nil): 式から参照可能なリスト． NamedList の要素は size_is, count_is の引数評価の場合 ParamDecl (関数仮引数)

name_list2(NamedList|Nil) : NamedList の要素は Decl (attribute, var) である．省略時 nil

RETURN: 評価した定数．評価できなかった場合は nil を返す

型は get_type で、評価する（定数として求められないときに使用できる） Array を返すのは attr{ int *a = 2, 3; int *b = a; }; の b の右辺を評価した場合



91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/tecsgen/core/expression.rb', line 91

def eval_const(name_list, name_list2 = nil)
  val = elements_eval_const(@elements, name_list, name_list2, 0)
  if val.is_a? IntegerVal
    return val.to_i
  elsif val.is_a? FloatVal
    return val.to_f
  elsif val.is_a? BoolVal
    return val.to_i
  elsif val.is_a? PointerVal
    return val.to_i # mikan エラー V1008 が発生してしまう
    # elsif val.kind_of? EnumVal then
    # enum mikan
  else
    # C_EXP, Array または nil ：そのまま返す
    return val
  end
end

#eval_const2(name_list, name_list2 = nil, nest = 0) ⇒ Object

定数式として評価する2(トライしてみる)

IntegerVal, FloatVal をそのまま返す（eval_const では Integer, Float に変換）



112
113
114
 
# File 'lib/tecsgen/core/expression.rb', line 112

def eval_const2(name_list, name_list2 = nil, nest = 0)
  val = elements_eval_const(@elements, name_list, name_list2, nest)
end

#evaluable?(*v) ⇒ Boolean

評価可能かチェックする

*v

可変個引数（任意の型）

すべてが BaseVal の子クラス（値）であれば、評価可能と判断する

Returns:

  • (Boolean) 


959
960
961
962
963
964
965
966
 
# File 'lib/tecsgen/core/expression.rb', line 959

def evaluable?(*v)
  v.each{|val|
    if !val.is_a?(BaseVal)
      return false
    end
  }
  return true
end

#get_allocator_rhs_elements(alloc_type) ⇒ Object

Express# get_allocator_rhs_elem alloc_type::Symbol :NORMAL_ALLOC|:INTERNAL_ALLOC|:RELAY_ALLOC 式がアロケータ指定子の右辺として妥当かチェックし、正しければ分解した値を返す return:

:NORMAL_ALLOC      [ cell_nsp, ep_name ]               # rhs = cell_nsp.ep_name    ex) Alloc.eAlloc
:INTERNAL_ALLOC    [ ep_name ]                         # rhs = ep_name             ex) eAlloc
:RELAY_ALLOC       [ cp_name, func_name, param_name ]  # rhs = cp_name.func_name.param_name



817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
 
# File 'lib/tecsgen/core/expression.rb', line 817

def get_allocator_rhs_elements(alloc_type)
  ele = @elements
  case alloc_type
  when :NORMAL_ALLOC
    if ele[0] != :OP_DOT || ele[1][0] != :IDENTIFIER # 1
      cdl_error("E1017 $1: rhs not \'Cell.ePort\' form", ele[0].to_s)
      return nil
    end
    cell_nsp  = elements[1][1]
    port_name = elements[2].val
    return [cell_nsp, port_name]
  when :INTERNAL_ALLOC
    if ele[0] == :IDENTIFIER
      if ele[1].is_name_only?
        return [ele[1].get_path[0]] # mikan a::b
      else
        cdl_error("E1018 $1: namespace cannot be specified", ele[1].to_s)
      end
    else
      cdl_error("E1019 $1: rhs not in 'allocator_entry_port' form", ele[1].to_s)
    end
  when :RELAY_ALLOC
    if ele[0] != :OP_DOT ||
        ele[1][0] != :OP_DOT || ele[1][1][0] != :IDENTIFIER || !ele[1][1][1].is_name_only? ||
        !ele[1][2].instance_of?(Token) || !ele[2].instance_of?(Token) # 1
      cdl_error("E1020 rhs not in 'call_port.func.param' form ($1)", ele[0].to_s) # S1086
    end
    func_name = ele[1][2]
    cp_name = ele[1][1][1].get_name
    param_name = ele[2].to_sym
    return [cp_name, func_name, param_name]
  end
  return nil
end

#get_elements ⇒ Object 



129
130
131
 
# File 'lib/tecsgen/core/expression.rb', line 129

def get_elements
  @elements
end

#get_rpn(param_list = nil, name_list2 = nil) ⇒ Object

Expression# 逆ポーランド文字列化

param_list

ParamlList 関数の引数リスト



233
234
235
 
# File 'lib/tecsgen/core/expression.rb', line 233

def get_rpn(param_list = nil, name_list2 = nil)
  return elements_rpn(@elements, param_list, name_list2)
end

#get_type(namedList) ⇒ Object

式の型を評価する

eval_const で値が得られない場合、型を導出可能であれば型を得る param を含んだ式は定数値を求められないが、型を得ることはできる 未定義変数を含んだ型は、得ることができない (ダミー型定義が返る)



121
122
123
 
# File 'lib/tecsgen/core/expression.rb', line 121

def get_type(namedList) # 名前空間の NamedList を指定
  elements_get_type(@elements, namedList)
end

#print ⇒ Object 



51
52
53
54
 
# File 'lib/tecsgen/core/expression.rb', line 51

def print
  # puts "expr: #{@elements}"
  puts "expr_string: #{self}"
end

#set_elements(elements) ⇒ Object 



875
876
877
 
# File 'lib/tecsgen/core/expression.rb', line 875

def set_elements(elements)
  @elements = elements
end

#show_tree(indent) ⇒ Object 



133
134
135
136
137
138
 
# File 'lib/tecsgen/core/expression.rb', line 133

def show_tree(indent)
  # mikan override してしまった print を呼出す方法がわからないのでこうした
  str = ""
  indent.times { str += "  " }
  puts "#{str}#{self}"
end

#to_CDL_str ⇒ Object

Expression#to_CDL_str

CDL 表現の文字列を生成



70
71
72
 
# File 'lib/tecsgen/core/expression.rb', line 70

def to_CDL_str
  return to_s
end

#to_s ⇒ Object

Expression# to_s

C 言語ソース向きの文字列を生成 (globa_name)



58
59
60
 
# File 'lib/tecsgen/core/expression.rb', line 58

def to_s
  elements_to_s(@elements)
end

#to_str(name_list, pre, post) ⇒ Object

Expression# to_str

C 言語ソース向きの文字列を生成 (globa_name)



64
65
66
 
# File 'lib/tecsgen/core/expression.rb', line 64

def to_str(name_list, pre, post)
  elements_to_s(@elements, name_list, pre, post)
end