SpadNodeFactory.spad

)abbrev package SNFAC SpadNodeFactory
SpadNodeFactory() : Exports == Implementation where
)include SpadTypeDefs.inc

  mt ==> nodeMappingType

  Exports ==> with
    booleanType : () -> N
    floatType : () -> N
    integerType : () -> N
    nonNegativeIntegerType : () -> N
    positiveIntegerType : () -> N
    outputFormType : () -> N
    stringType : () -> N
    symbolType : () -> N
    voidType : () -> N
    categoryType : () -> N
    baseType : () -> N
    undefinedType : () -> N
    setCategoryType : () -> N
    orderedSetType : () -> N

    typeVar : () -> N
    typeVar : PI -> N
    typeVar : (PI, PI) -> N

    nodeRef : (PI, PI) -> N

    makeRecordFunList : N -> List(TD)
    makeUnionFunList : N -> List(TD)

  Implementation ==> add
    booleanType () == nodeApp(['Boolean], [])
    floatType () == nodeApp(['DoubleFloat], [])
    integerType () == nodeApp(['Integer], [])
    nonNegativeIntegerType () == nodeApp(['NonNegativeInteger], [])
    positiveIntegerType () == nodeApp(['PositiveInteger], [])
    outputFormType () == nodeApp(['OutputForm], [])
    stringType () == nodeApp(['String], [])
    symbolType () == nodeApp(['Symbol], [])
    voidType () == nodeApp(['Void], [])
    categoryType () == nodeApp(['Category], [])
    baseType () == nodeApp(['Type], [])
    setCategoryType () == nodeApp(['SetCategory], [])
    orderedSetType () == nodeApp(['OrderedSet], [])
    undefinedType() == [["%undef"]$MR]

    typeVar() == [[0, 0]$TV]
    typeVar(j) == [[0, j]$TV]
    typeVar(i, j) == [[i, j]$TV]

    nodeRef(i, j) == [[i, j]$NR]

    makeRecordFunList n ==
      r := n :: RT
      funs : List(TD) :=
       ([[['=], mt([n, n], booleanType())],
         [['~=], mt([n, n], booleanType())],
         [['copy], mt([n], n)],
         [['coerce], mt([n], outputFormType())],
         [['construct], mt([f.type for f in fields r], n)]
        ])
      for f in fields r repeat
        s : N := [string(f.expr :: Symbol)]
        r : N := f.type
        funs := ([[f.expr, s],
                  [['elt], mt([n, s], r)],
                  [['setelt!], mt([n, s, r], r)], :funs])
      funs

    makeUnionFunList n ==
      u := n :: UT
      funs : List(TD) :=
       ([[['=], mt([n, n], booleanType())],
         [['~=], mt([n, n], booleanType())],
         [['coerce], mt([n], outputFormType())]
        ])
      vs := variants u
      if typeDecl? vs.1 then
        for v in vs repeat
          td := v :: TD
          s : N := [string(td.expr :: Symbol)]
          -- PARSER BUG: split into three lines and the parser will fail
          funs := [[['construct], mt([td.type], n)], [td.expr, s],
                   [['elt], mt([n, s], td.type)], :funs]
      else
        for v in vs repeat
          funs := [[['construct], mt([v], n)], 
                   [['coerce], mt([n], v)], :funs]
          if string? v then
            funs := [[[v :: String :: Symbol], v], :funs]
      funs