Ternary CC compiler

icgrep/pablo/printer_pablos.cpp

             out << ")";
         } else if (const Ternary * tern = dyn_cast<Ternary>(stmt)) {
             out << " = pablo.Ternary(";
-            print(tern->getMask(), out);
+            out.write_hex(tern->getMask()->value());

icgrep/cc/cc_compiler.cpp

 #include <llvm/IR/DerivedTypes.h>
 #include <llvm/Support/ErrorHandling.h>
 #include <llvm/Support/raw_ostream.h>
+#include <cmath>
 
 using namespace re;
 using namespace pablo;
 using namespace llvm;
 
 namespace cc {
-    CC_Compiler::CC_Compiler(pablo::PabloBlock * scope)
-    : mBuilder(scope) {
-    }
+using octet_pair_t = Parabix_Ternary_CC_Compiler::octet_pair_t;
+using octets_intervals_union_t = Parabix_Ternary_CC_Compiler::octets_intervals_union_t;
 
-Parabix_CC_Compiler::Parabix_CC_Compiler(pablo::PabloBlock * scope, std::vector<pablo::PabloAST *> basisBitSet)
-: CC_Compiler(scope)
-, mEncodingBits(basisBitSet.size())
-, mBasisBit(basisBitSet) {
-    mEncodingMask = (static_cast<unsigned>(1) << mEncodingBits) - static_cast<unsigned>(1);
+CC_Compiler::CC_Compiler(pablo::PabloBlock * scope)
+: mBuilder(scope) {
 }
 
-PabloAST * Parabix_CC_Compiler::compileCC(const std::string & canonicalName, const CC *cc, PabloBlock & block) {
-    PabloAST * const var = charset_expr(cc, block);
-    if (LLVM_LIKELY(isa<Statement>(var))) {
-        cast<Statement>(var)->setName(block.makeName(canonicalName));
-    }
-    return var;
+CC_Compiler_Common::CC_Compiler_Common(unsigned encodingBits, std::vector<pablo::PabloAST *> basisBit, unsigned encodingMask)
+: mEncodingBits(encodingBits)
+, mBasisBit(basisBit)
+, mEncodingMask(encodingMask) {
 }
 
-PabloAST * Parabix_CC_Compiler::compileCC(const std::string & canonicalName, const CC *cc, PabloBuilder & builder) {
-    PabloAST * const var = charset_expr(cc, builder);
-    if (LLVM_LIKELY(isa<Statement>(var))) {
-        cast<Statement>(var)->setName(builder.makeName(canonicalName));
-    }
-    return var;
-}
-    
 template<typename PabloBlockOrBuilder>
-PabloAST * Parabix_CC_Compiler::charset_expr(const CC * cc, PabloBlockOrBuilder & pb) {
-    if (cc->empty()) {
-        return pb.createZeroes();
-    }
-    if (cc->size() > 2) {
-        bool combine = true;
-        for (const interval_t & i : *cc) {
-            if (lo_codepoint(i) != hi_codepoint(i)) {
-                combine = false;
-                break;
-            }
-        }
-        if (combine) {
-            auto i = cc->begin(), e = cc->end();
-            for (auto j = i; ++j != e; i = j) {
-                if ((lo_codepoint(i) + 2) != lo_codepoint(j)) {
-                    combine  = false;
-                    break;
-                }
-            }
-            if (combine) {
-                codepoint_t lo = lo_codepoint(cc->front());
-                codepoint_t hi = lo_codepoint(cc->back());
-                PabloAST * even_odd = getBasisVar(0, pb);
-                if ((lo & 1) == 0) {
-                    even_odd = pb.createNot(even_odd);
-                }
-                lo &= (mEncodingMask - 1);
-                hi |= (mEncodingMask ^ (mEncodingMask - 1));
-                PabloAST * expr = make_range(lo, hi, pb);
-                return pb.createAnd(expr, even_odd);
-            }
-        }
-    }
-    PabloAST * expr = nullptr;
-    for (const interval_t & i : *cc) {
-        PabloAST * temp = char_or_range_expr(lo_codepoint(i), hi_codepoint(i), pb);
-        expr = (expr == nullptr) ? temp : pb.createOr(expr, temp);
-    }
-    return pb.createInFile(expr);
-    
-}
-
-template<typename PabloBlockOrBuilder>
-PabloAST * Parabix_CC_Compiler::bit_pattern_expr(const unsigned pattern, unsigned selected_bits, PabloBlockOrBuilder & pb) {
+PabloAST * CC_Compiler_Common::bit_pattern_expr(const unsigned pattern, unsigned selected_bits, PabloBlockOrBuilder & pb) {
     if (LLVM_UNLIKELY(selected_bits == 0)) {
         return pb.createOnes();
     } else {
 }
 
 template<typename PabloBlockOrBuilder>
-inline PabloAST * Parabix_CC_Compiler::char_test_expr(const codepoint_t ch, PabloBlockOrBuilder &pb) {
-    return bit_pattern_expr(ch, mEncodingMask, pb);
-}
-
-template<typename PabloBlockOrBuilder>
-PabloAST * Parabix_CC_Compiler::make_range(const codepoint_t n1, const codepoint_t n2, PabloBlockOrBuilder & pb) {
+PabloAST * CC_Compiler_Common::make_range(const codepoint_t n1, const codepoint_t n2, PabloBlockOrBuilder & pb) {
     codepoint_t diff_count = 0;
 
     for (codepoint_t diff_bits = n1 ^ n2; diff_bits; diff_count++, diff_bits >>= 1);
 }
 
 template<typename PabloBlockOrBuilder>
-PabloAST * Parabix_CC_Compiler::GE_Range(const unsigned N, const unsigned n, PabloBlockOrBuilder &pb) {
+PabloAST * CC_Compiler_Common::GE_Range(const unsigned N, const unsigned n, PabloBlockOrBuilder &pb) {
     if (N == 0) {
         return pb.createOnes(); //Return a true literal.
     }
 }
 
 template<typename PabloBlockOrBuilder>
-PabloAST * Parabix_CC_Compiler::LE_Range(const unsigned N, const unsigned n, PabloBlockOrBuilder & pb) {
+PabloAST * CC_Compiler_Common::LE_Range(const unsigned N, const unsigned n, PabloBlockOrBuilder & pb) {
     /*
       If an N-bit pattern is all ones, then it is always true that any n-bit value is LE this pattern.
       Handling this as a special case avoids an overflow issue with n+1 requiring more than N bits.
 }
 
 template<typename PabloBlockOrBuilder>
-inline PabloAST * Parabix_CC_Compiler::char_or_range_expr(const codepoint_t lo, const codepoint_t hi, PabloBlockOrBuilder &pb) {
+inline PabloAST * CC_Compiler_Common::char_test_expr(const codepoint_t ch, PabloBlockOrBuilder &pb) {
+    return bit_pattern_expr(ch, mEncodingMask, pb);
+}
+
+template<typename PabloBlockOrBuilder>
+inline PabloAST * CC_Compiler_Common::char_or_range_expr(const codepoint_t lo, const codepoint_t hi, PabloBlockOrBuilder &pb) {
     if (lo == hi) {
         return char_test_expr(lo, pb);
     } else if (lo < hi) {
 }
 
 template<typename PabloBlockOrBuilder>
-inline PabloAST * Parabix_CC_Compiler::getBasisVar(const unsigned i, PabloBlockOrBuilder & pb) const {
+inline PabloAST * CC_Compiler_Common::getBasisVar(const unsigned i, PabloBlockOrBuilder & pb) const {
     assert (i < mEncodingBits);
     return mBasisBit[i];
 }
 
+Parabix_CC_Compiler::Parabix_CC_Compiler(pablo::PabloBlock * scope, std::vector<pablo::PabloAST *> basisBitSet)
+: CC_Compiler(scope)
+, CC_Compiler_Common(basisBitSet.size(), basisBitSet, (static_cast<unsigned>(1) << basisBitSet.size()) - static_cast<unsigned>(1)) {
+}
+
+PabloAST * Parabix_CC_Compiler::compileCC(const std::string & canonicalName, const CC *cc, PabloBlock & block) {
+    PabloAST * const var = charset_expr(cc, block);
+    if (LLVM_LIKELY(isa<Statement>(var))) {
+        cast<Statement>(var)->setName(block.makeName(canonicalName));
+    }
+    return var;
+}
+
+PabloAST * Parabix_CC_Compiler::compileCC(const std::string & canonicalName, const CC *cc, PabloBuilder & builder) {
+    PabloAST * const var = charset_expr(cc, builder);
+    if (LLVM_LIKELY(isa<Statement>(var))) {
+        cast<Statement>(var)->setName(builder.makeName(canonicalName));
+    }
+    return var;
+}
+    
+template<typename PabloBlockOrBuilder>
+PabloAST * Parabix_CC_Compiler::charset_expr(const CC * cc, PabloBlockOrBuilder & pb) {
+    if (cc->empty()) {
+        return pb.createZeroes();
+    }
+    if (cc->size() > 2) {
+        bool combine = true;
+        for (const interval_t & i : *cc) {
+            if (lo_codepoint(i) != hi_codepoint(i)) {
+                combine = false;
+                break;
+            }
+        }
+        if (combine) {
+            auto i = cc->begin(), e = cc->end();
+            for (auto j = i; ++j != e; i = j) {
+                if ((lo_codepoint(i) + 2) != lo_codepoint(j)) {
+                    combine  = false;
+                    break;
+                }
+            }
+            if (combine) {
+                codepoint_t lo = lo_codepoint(cc->front());
+                codepoint_t hi = lo_codepoint(cc->back());
+                PabloAST * even_odd = getBasisVar(0, pb);
+                if ((lo & 1) == 0) {
+                    even_odd = pb.createNot(even_odd);
+                }
+                lo &= (mEncodingMask - 1);
+                hi |= (mEncodingMask ^ (mEncodingMask - 1));
+                PabloAST * expr = make_range(lo, hi, pb);
+                return pb.createAnd(expr, even_odd);
+            }
+        }
+    }
+    PabloAST * expr = nullptr;
+    for (const interval_t & i : *cc) {
+        PabloAST * temp = char_or_range_expr(lo_codepoint(i), hi_codepoint(i), pb);
+        expr = (expr == nullptr) ? temp : pb.createOr(expr, temp);
+    }
+    return pb.createInFile(expr);
+    
+}
     
 PabloAST * compileCCfromCodeUnitStream(const CC * cc, PabloAST * codeUnitStream, PabloBuilder & pb) {
     const Alphabet * a = cc->getAlphabet();
     return compileCCfromCodeUnitStream(cc, mCodeUnitStream, b);
 }
 
+Parabix_Ternary_CC_Compiler::Parabix_Ternary_CC_Compiler(pablo::PabloBlock * scope, std::vector<pablo::PabloAST *> basisBitSet)
+: CC_Compiler(scope)
+, CC_Compiler_Common(basisBitSet.size(), basisBitSet, (static_cast<unsigned>(1) << basisBitSet.size()) - static_cast<unsigned>(1)) {
+}
+
+PabloAST * Parabix_Ternary_CC_Compiler::compileCC(const std::string & canonicalName, const CC *cc, PabloBlock & block) {
+    PabloAST * const var = charset_expr(cc, block);
+    if (LLVM_LIKELY(isa<Statement>(var))) {
+        cast<Statement>(var)->setName(block.makeName(canonicalName));
+    }
+    return var;
+}
+
+PabloAST * Parabix_Ternary_CC_Compiler::compileCC(const std::string & canonicalName, const CC *cc, PabloBuilder & builder) {
+    PabloAST * const var = charset_expr(cc, builder);
+    if (LLVM_LIKELY(isa<Statement>(var))) {
+        cast<Statement>(var)->setName(builder.makeName(canonicalName));
+    }
+    return var;
+}
+
+template<typename PabloBlockOrBuilder>
+pablo::PabloAST * Parabix_Ternary_CC_Compiler::charset_expr(const re::CC *cc, PabloBlockOrBuilder & pb) {
+    if (cc->empty()) {
+        return pb.createZeroes();
+    }
+    octets_intervals_union_t octets_intervals = make_octets_intervals_union(cc);
+    std::vector<octet_pair_t> octets = octets_in_union(octets_intervals);
+    std::vector<interval_t> intervals = intervals_in_union(octets_intervals);
+    PabloAST *expr1 = make_octets_expr(octets, pb);
+    PabloAST *expr2 = make_intervals_expr(intervals, pb);
+    return pb.createInFile(pb.createOr(expr1, expr2));
+}
+
+template<typename PabloBlockOrBuilder>
+PabloAST * Parabix_Ternary_CC_Compiler::make_intervals_expr(const std::vector<interval_t> intervals, PabloBlockOrBuilder & pb) {
+    PabloAST * expr = nullptr;
+    for (auto i : intervals) {
+        PabloAST * temp = char_or_range_expr(lo_codepoint(i), hi_codepoint(i), pb);
+        expr = (expr == nullptr) ? temp : pb.createOr(expr, temp);
+    }
+    if (expr == nullptr) return pb.createZeroes();
+    return expr;
+}
+
+template<typename PabloBlockOrBuilder>
+PabloAST * Parabix_Ternary_CC_Compiler::make_octets_expr(const std::vector<octet_pair_t> octets, PabloBlockOrBuilder & pb) {
+    std::vector<PabloAST *> terms;
+    for (auto octet : octets) {
+        uint8_t mask = octet_mask(octet);
+        uint8_t mid3_mask = 1 << ((octet_base_codepoint(octet) & 0x38) >> 3);
+        uint8_t hi2_mask = 1 << ((octet_base_codepoint(octet) & 0xC0) >> 6);
+        PabloAST * mid3 = pb.createTernary(pb.getInteger(mid3_mask), getBasisVar(5, pb), getBasisVar(4, pb), getBasisVar(3, pb));
+        PabloAST * hi5 = pb.createTernary(pb.getInteger(hi2_mask << 4), mid3, getBasisVar(7, pb), getBasisVar(6, pb));
+        if (mask != 0xFF) {
+            PabloAST * lo3 = pb.createTernary(pb.getInteger(mask), getBasisVar(2, pb), getBasisVar(1, pb), getBasisVar(0, pb));
+            terms.push_back(pb.createAnd(hi5, lo3));
+        } else {
+            if (terms.empty()) {
+                terms.push_back(hi5);
+            } else {
+                terms[terms.size()-1] = pb.createOr(terms.back(), hi5);
+            }
+        }
+    }
+    if (terms.empty()) return pb.createZeroes();
+    //Reduce the list so that all of the expressions are contained within a single expression.
+    std::vector<PabloAST *> temp;
+    temp.reserve(terms.size());
+    do {
+        for (unsigned i = 0; i < (terms.size() / 3); i++) {
+            temp.push_back(pb.createOr3(terms[3 * i], terms[(3 * i) + 1], terms[(3 * i) + 2]));
+        }
+        for (unsigned i = 0; i < (terms.size() % 3); i++) {
+            temp.push_back(terms[terms.size() - i - 1]);
+        }
+        terms.swap(temp);
+        temp.clear();
+    } while (terms.size() >= 3);
+    assert (terms.size() == 2 || terms.size() == 1);
+    if (terms.size() == 2) {
+        return pb.createOr(terms.front(), terms.back());
+    } else {
+        return terms.front();
+    }
+}
+
+octets_intervals_union_t Parabix_Ternary_CC_Compiler::make_octets_intervals_union(const re::CC *cc) {
+    // The low value of an octet is always 0x0 or 0x8
+    // 0x60 -> 0110 0000, 0x67 -> 0110 0111
+    // 0x68 -> 0110 1000, 0x6F -> 0110 1111
+    // Example of input: <0x67, 0x69>, <0x6B, 0x6B>, <0x70, 0x70>
+    // Output: <0x60, 10000000>, <0x68, 00001011>, <0x70, 00000001>
+    std::vector<octet_pair_t> octets;
+    std::vector<interval_t> intervals;
+    for (const interval_t & i : *cc) {
+        codepoint_t lo_cp = lo_codepoint(i);
+        codepoint_t hi_cp = hi_codepoint(i);
+        codepoint_t fst_octet = lo_cp & 0xFFFFFFF8;
+        codepoint_t lst_octet = hi_cp & 0xFFFFFFF8;
+        if (fst_octet != lst_octet) {
+            intervals.push_back(i);
+            continue;
+        }
+        for (codepoint_t octet = fst_octet; octet <= lst_octet; octet += 0x8) {
+            // lo_bit and hi_bit values are always in the range 0..7
+            // as these are all possible values for selected bits in an octet
+            uint8_t mask = 0;
+            uint8_t lo_bit = 0;
+            uint8_t hi_bit = 0x7;
+            if (octet > fst_octet && octet < lst_octet) mask = 0xFF;
+            else if (octet == fst_octet && octet < lst_octet) lo_bit = lo_cp - octet;
+            else if (octet > fst_octet && octet == lst_octet) hi_bit = hi_cp - octet;
+            else if (fst_octet == lst_octet) {
+                lo_bit = lo_cp - octet;
+                hi_bit = hi_cp - octet;
+            }
+            if (mask == 0) {
+                for (auto j = lo_bit; j <= hi_bit; j++)
+                    mask |= 1 << j;
+            }
+            if (!octets.empty()) {
+                octet_pair_t * lst_selected = &(octets.back());
+                if (octet == octet_base_codepoint(*lst_selected)) {
+                    mask |= octet_mask(*lst_selected);
+                    lst_selected->second = mask;
+                    continue;
+                }
+            }
+            octets.push_back(std::make_pair(octet, mask));
+        }
+    }
+    return std::make_pair(octets, intervals);
+}
+
 } // end of namespace cc

icgrep/cc/cc_compiler.h

 #include <re/re_cc.h>
 #include <pablo/builder.hpp>
 #include <cc/alphabet.h>
+#include <stdint.h>
 
 namespace cc {
 
 class CC_Compiler {
 public:
-    
-    virtual pablo::PabloAST * compileCC(const re::CC *cc) = 0;
-    
-    virtual pablo::PabloAST * compileCC(const re::CC *cc, pablo::PabloBlock & block) = 0;
-    
-    virtual pablo::PabloAST * compileCC(const re::CC *cc, pablo::PabloBuilder & builder) = 0;
-    
+    virtual pablo::PabloAST * compileCC(const re::CC *cc) {
+        return compileCC(cc, mBuilder);
+    }
+    virtual pablo::PabloAST * compileCC(const re::CC *cc, pablo::PabloBlock & block) {
+        return compileCC(cc->canonicalName(), cc, block);
+    }
+    virtual pablo::PabloAST * compileCC(const re::CC *cc, pablo::PabloBuilder & builder) {
+        return compileCC(cc->canonicalName(), cc, builder);
+    }
     virtual pablo::PabloAST * compileCC(const std::string & canonicalName, const re::CC *cc, pablo::PabloBlock & block) = 0;
-    
     virtual pablo::PabloAST * compileCC(const std::string & canonicalName, const re::CC *cc, pablo::PabloBuilder & builder) = 0;
-    
     virtual ~CC_Compiler(){}
 
 protected:
     CC_Compiler(pablo::PabloBlock * scope);
     pablo::PabloBuilder             mBuilder;
 };
-    
-    
-class Parabix_CC_Compiler : public CC_Compiler {
+
+
+class CC_Compiler_Common {
 public:
-    
-    Parabix_CC_Compiler(pablo::PabloBlock * scope, std::vector<pablo::PabloAST *> basisBitSet);
-    
-    pablo::PabloAST * compileCC(const re::CC *cc) override;
-    
-    pablo::PabloAST * compileCC(const re::CC *cc, pablo::PabloBlock & block) override;
-    
-    pablo::PabloAST * compileCC(const re::CC *cc, pablo::PabloBuilder & builder) override;
-    
-    pablo::PabloAST * compileCC(const std::string & name, const re::CC *cc, pablo::PabloBlock & block) override;
+    ~CC_Compiler_Common() {}
 
-    pablo::PabloAST * compileCC(const std::string & name, const re::CC *cc, pablo::PabloBuilder & builder) override;
-    
-    ~Parabix_CC_Compiler() {}
+protected:
+    CC_Compiler_Common(unsigned encodingBits, std::vector<pablo::PabloAST *> basisBit, unsigned encodingMask);
 
-private:
+protected:
     template<typename PabloBlockOrBuilder>
     pablo::PabloAST * getBasisVar(const unsigned n, PabloBlockOrBuilder & pb) const;
     template<typename PabloBlockOrBuilder>
     pablo::PabloAST * LE_Range(const unsigned N, const unsigned n, PabloBlockOrBuilder & pb);
     template<typename PabloBlockOrBuilder>
     pablo::PabloAST * char_or_range_expr(const re::codepoint_t lo, const re::codepoint_t hi, PabloBlockOrBuilder & pb);
-    template<typename PabloBlockOrBuilder>
-    pablo::PabloAST * charset_expr(const re::CC *cc, PabloBlockOrBuilder & pb);
-private:    
+
+protected:  
     const unsigned                  mEncodingBits;
     std::vector<pablo::PabloAST *>  mBasisBit;
     unsigned                        mEncodingMask;
 };
-
-    inline pablo::PabloAST * Parabix_CC_Compiler::compileCC(const re::CC *cc) {
-        return compileCC(cc, mBuilder);
-    }
     
-    inline pablo::PabloAST * Parabix_CC_Compiler::compileCC(const re::CC *cc, pablo::PabloBlock & block) {
-        return compileCC(cc->canonicalName(), cc, block);
-    }
-    
-    inline pablo::PabloAST * Parabix_CC_Compiler::compileCC(const re::CC *cc, pablo::PabloBuilder & builder) {
-        return compileCC(cc->canonicalName(), cc, builder);
-    }
     
+class Parabix_CC_Compiler : public CC_Compiler, public CC_Compiler_Common {
+public:
+    using CC_Compiler::compileCC;
+
+    Parabix_CC_Compiler(pablo::PabloBlock * scope, std::vector<pablo::PabloAST *> basisBitSet);
+    pablo::PabloAST * compileCC(const std::string & name, const re::CC *cc, pablo::PabloBlock & block) override;
+    pablo::PabloAST * compileCC(const std::string & name, const re::CC *cc, pablo::PabloBuilder & builder) override;
+    ~Parabix_CC_Compiler() {}
+
+private:
+    template<typename PabloBlockOrBuilder>
+    pablo::PabloAST * charset_expr(const re::CC *cc, PabloBlockOrBuilder & pb);
+};
     
 
 class Direct_CC_Compiler : public CC_Compiler {
 public:
-    
+    using CC_Compiler::compileCC;
+
     Direct_CC_Compiler(pablo::PabloBlock * scope, pablo::PabloAST * codeUnitStream);
-    
-    pablo::PabloAST * compileCC(const re::CC *cc) override;
-    
-    pablo::PabloAST * compileCC(const re::CC *cc, pablo::PabloBlock & block) override;
-    
-    pablo::PabloAST * compileCC(const re::CC *cc, pablo::PabloBuilder & builder) override;
-    
     pablo::PabloAST * compileCC(const std::string & name, const re::CC *cc, pablo::PabloBlock & block) override;
-    
     pablo::PabloAST * compileCC(const std::string & name, const re::CC *cc, pablo::PabloBuilder & builder) override;
-    
     ~Direct_CC_Compiler() {}
     
 private:
     pablo::PabloAST *               mCodeUnitStream;
 };
 
-    
-inline pablo::PabloAST * Direct_CC_Compiler::compileCC(const re::CC *cc) {
-    return compileCC(cc, mBuilder);
-}
-
-inline pablo::PabloAST * Direct_CC_Compiler::compileCC(const re::CC *cc, pablo::PabloBlock & block) {
-    return compileCC(cc->canonicalName(), cc, block);
-}
 
-inline pablo::PabloAST * Direct_CC_Compiler::compileCC(const re::CC *cc, pablo::PabloBuilder & builder) {
-    return compileCC(cc->canonicalName(), cc, builder);
-}
+class Parabix_Ternary_CC_Compiler : public CC_Compiler, public CC_Compiler_Common {
+public:
+    using CC_Compiler::compileCC;
+    using octet_pair_t = std::pair<re::codepoint_t, uint8_t>;
+    using octets_intervals_union_t = std::pair<std::vector<octet_pair_t>, std::vector<re::interval_t>>;
 
+    Parabix_Ternary_CC_Compiler(pablo::PabloBlock * scope, std::vector<pablo::PabloAST *> basisBitSet);
+    pablo::PabloAST * compileCC(const std::string & name, const re::CC *cc, pablo::PabloBlock & block) override;
+    pablo::PabloAST * compileCC(const std::string & name, const re::CC *cc, pablo::PabloBuilder & builder) override;
+    ~Parabix_Ternary_CC_Compiler() {}
+private:
+    template<typename PabloBlockOrBuilder>
+    pablo::PabloAST * charset_expr(const re::CC *cc, PabloBlockOrBuilder & pb);
+    template<typename PabloBlockOrBuilder>
+    pablo::PabloAST * make_octets_expr(const std::vector<octet_pair_t> octets, PabloBlockOrBuilder & pb);
+    template<typename PabloBlockOrBuilder>
+    pablo::PabloAST * make_intervals_expr(const std::vector<re::interval_t> intervals, PabloBlockOrBuilder & pb);
+    octets_intervals_union_t make_octets_intervals_union(const re::CC *cc);
+    inline re::codepoint_t octet_base_codepoint(const octet_pair_t & i) {
+        return std::get<0>(i);
+    }
+    inline uint8_t octet_mask(const octet_pair_t & i) {
+        return std::get<1>(i);
+    }
+    inline std::vector<octet_pair_t> octets_in_union(const octets_intervals_union_t & i) {
+        return std::get<0>(i);
+    }
+    inline std::vector<re::interval_t> intervals_in_union(const octets_intervals_union_t & i) {
+        return std::get<1>(i);
+    }
+};
 
 
 pablo::PabloAST * compileCCfromCodeUnitStream(const re::CC *cc, pablo::PabloAST * codeUnitStream, pablo::PabloBuilder & pb);

icgrep/cc/cc_compiler_target.cpp

+/*
+ *  Copyright (c) 2019 International Characters.
+ *  This software is licensed to the public under the Open Software License 3.0.
+ */
+
+#include "cc_compiler_target.h"
+#include <toolchain/toolchain.h>
+
+using namespace std;
+using namespace llvm;
+using namespace codegen;
+using namespace pablo;
+using namespace re;
+
+namespace cc {
+
+Parabix_CC_Compiler_Builder::Parabix_CC_Compiler_Builder(pablo::PabloBlock * scope, std::vector<pablo::PabloAST *> basisBitSet)
+: CC_Compiler(scope) {
+    if (LLVM_LIKELY(codegen::CCCOption.compare("binary") == 0)) {
+        ccc = make_unique<Parabix_CC_Compiler>(scope, basisBitSet);
+    } else if (LLVM_LIKELY(codegen::CCCOption.compare("ternary") == 0)) {
+        ccc = make_unique<Parabix_Ternary_CC_Compiler>(scope, basisBitSet);
+    } else {
+        llvm::report_fatal_error("Specified character class compiler is not valid");
+    }
+}
+
+PabloAST * Parabix_CC_Compiler_Builder::compileCC(const std::string & canonicalName, const CC *cc, PabloBlock & block) {
+    return ccc->compileCC(canonicalName, cc, block);
+}
+
+PabloAST * Parabix_CC_Compiler_Builder::compileCC(const std::string & canonicalName, const CC *cc, PabloBuilder & builder) {
+    return ccc->compileCC(canonicalName, cc, builder);
+}
+
+}
\ No newline at end of file

icgrep/cc/cc_compiler_target.h

+/*
+ *  Copyright (c) 2019 International Characters.
+ *  This software is licensed to the public under the Open Software License 3.0.
+ */
+
+#ifndef CC_COMPILER_TARGET_H
+#define CC_COMPILER_TARGET_H
+
+#include "cc_compiler.h"
+
+namespace cc {
+
+class Parabix_CC_Compiler_Builder : public CC_Compiler {
+public:
+    using CC_Compiler::compileCC;
+    
+    Parabix_CC_Compiler_Builder(pablo::PabloBlock * scope, std::vector<pablo::PabloAST *> basisBitSet);
+    pablo::PabloAST * compileCC(const std::string & name, const re::CC *cc, pablo::PabloBlock & block) override;
+    pablo::PabloAST * compileCC(const std::string & name, const re::CC *cc, pablo::PabloBuilder & builder) override;
+    ~Parabix_CC_Compiler_Builder() {}
+    
+protected:
+    std::unique_ptr<CC_Compiler> ccc;
+};
+
+}
+
+#endif
\ No newline at end of file

icgrep/cc/cc_kernel.cpp

 #include "cc_kernel.h"
 #include <re/re_cc.h>
 #include <cc/cc_compiler.h>
+#include <cc/cc_compiler_target.h>
 #include <kernels/kernel_builder.h>
 #include <llvm/Support/raw_ostream.h>
 
 
 void CharacterClassKernelBuilder::generatePabloMethod() {
     PabloBuilder pb(getEntryScope());
-    std::unique_ptr<CC_Compiler> ccc;
+    std::unique_ptr<cc::CC_Compiler> ccc;
     bool useDirectCC = getInput(0)->getType()->getArrayNumElements() == 1;
     if (useDirectCC) {
         ccc = make_unique<cc::Direct_CC_Compiler>(getEntryScope(), pb.createExtract(getInput(0), pb.getInteger(0)));
     } else {
-        ccc = make_unique<cc::Parabix_CC_Compiler>(getEntryScope(), getInputStreamSet("sourceStream"));
+        ccc = make_unique<cc::Parabix_CC_Compiler_Builder>(getEntryScope(), getInputStreamSet("sourceStream"));
     }
     Var * outputVar = getOutputStreamVar("ccStream");
     PabloAST * nonNull = nullptr;

[lperesde]

Hi Prof. @cameron, I hope you don't mind I am printing the hex value here (to keep the pattern of the language UTF8_61_63, when I pass [a-c], for example