support MUL, SHL, SHR, ... etc in native/eda

diff --git a/core/scf_3ac.c b/core/scf_3ac.c
index f19f82b3efacb2acda152cd27559db2e736806ad..37989c2fa1aba21cd11167fc592afb45ce0e91d7 100644 (file)
--- a/core/scf_3ac.c
+++ b/core/scf_3ac.c
@@ -621,9 +621,11 @@ int scf_3ac_code_to_dag(scf_3ac_code_t* c, scf_list_t* dag)
                if (ret < 0)
                        return ret;
 
+               if (SCF_OP_ASSIGN == c->op->type && src->dag_node == dst->dag_node)
+                       return 0;
+
                scf_dag_node_t* dn_src;
                scf_dag_node_t* dn_parent;
-               scf_dag_node_t* dn_child;
                scf_dag_node_t* dn_assign;
                scf_variable_t* v_assign = NULL;
 
@@ -634,27 +636,24 @@ int scf_3ac_code_to_dag(scf_3ac_code_t* c, scf_list_t* dag)
 
                scf_list_add_tail(dag, &dn_assign->list);
 
-               ret = scf_dag_node_add_child(dn_assign, dst->dag_node);
-               if (ret < 0)
-                       return ret;
-
                dn_src = src->dag_node;
 
                if (dn_src->parents && dn_src->parents->size > 0 && !scf_variable_may_malloced(dn_src->var)) {
                        dn_parent        = dn_src->parents->data[dn_src->parents->size - 1];
 
                        if (SCF_OP_ASSIGN == dn_parent->type) {
-                               assert(2      == dn_parent->childs->size);
-                               dn_child      =  dn_parent->childs->data[1];
 
-                               return scf_dag_node_add_child(dn_assign, dn_child);
+                               assert(2 == dn_parent->childs->size);
+                               dn_src    = dn_parent->childs->data[1];
                        }
                }
 
-               ret = scf_dag_node_add_child(dn_assign, src->dag_node);
+               ret = scf_dag_node_add_child(dn_assign, dst->dag_node);
                if (ret < 0)
                        return ret;
 
+               return scf_dag_node_add_child(dn_assign, dn_src);
+
        } else if (scf_type_is_assign_array_index(c->op->type)
                        || scf_type_is_assign_dereference(c->op->type)
                        || scf_type_is_assign_pointer(c->op->type)) {

diff --git a/core/scf_core_types.h b/core/scf_core_types.h
index 339f380b09da6fcd64a2c2c65da7282b75817c4e..af2aea87d155b04629b0bb0daf770f678973af7e 100644 (file)
--- a/core/scf_core_types.h
+++ b/core/scf_core_types.h
@@ -53,6 +53,7 @@ enum scf_core_types
        SCF_OP_BIT_AND,     // &
        SCF_OP_BIT_OR,      // |
        SCF_OP_BIT_NOT,     // ~
+       SCF_OP_BIT_XOR,     // ^
 
        SCF_OP_LOGIC_AND,   // &&
        SCF_OP_LOGIC_OR,    // ||
@@ -192,6 +193,10 @@ enum scf_core_types
        SCF_VAR_CHAR,       // char variable
 
        SCF_VAR_I8,
+       SCF_VAR_I1,
+       SCF_VAR_I2,
+       SCF_VAR_I3,
+       SCF_VAR_I4,
        SCF_VAR_I16,
        SCF_VAR_I32,
        SCF_VAR_INT = SCF_VAR_I32,
@@ -202,9 +207,9 @@ enum scf_core_types
        SCF_VAR_U8,
        SCF_VAR_VOID,
        SCF_VAR_BIT,
-       SCF_VAR_BIT2,
-       SCF_VAR_BIT3,
-       SCF_VAR_BIT4,
+       SCF_VAR_U2,
+       SCF_VAR_U3,
+       SCF_VAR_U4,
        SCF_VAR_U16,
        SCF_VAR_U32,
        SCF_VAR_U64,

diff --git a/core/scf_dag.h b/core/scf_dag.h
index b02bd116b87ecce051687cf8055ab74ad5455da1..65191e179c8abbe823094b1f6f6bd0d863048134 100644 (file)
--- a/core/scf_dag.h
+++ b/core/scf_dag.h
@@ -37,7 +37,8 @@ struct scf_dag_node_s
        void*               rabi;
        void*               rabi2;
 
-       ScfEpin*            pins[256];
+#define SCF_EDA_MAX_BITS 256
+       ScfEpin*            pins[SCF_EDA_MAX_BITS];
        int                 n_pins;
 
        intptr_t            color;

diff --git a/core/scf_lex_word.h b/core/scf_lex_word.h
index 24e6a2eca743b6fef3bdec95e79bc6b9b4f9800e..d37a758eb9dee27fcb7fb20ff94631edf6633d33 100644 (file)
--- a/core/scf_lex_word.h
+++ b/core/scf_lex_word.h
@@ -114,18 +114,25 @@ enum scf_lex_words
 
        // data types
        SCF_LEX_WORD_KEY_CHAR,          // char
-       SCF_LEX_WORD_KEY_BIT,       // bit
 
        SCF_LEX_WORD_KEY_INT,           // int
        SCF_LEX_WORD_KEY_FLOAT,     // float
        SCF_LEX_WORD_KEY_DOUBLE,        // double
 
        SCF_LEX_WORD_KEY_INT8,      // int8_t
+       SCF_LEX_WORD_KEY_INT1,      // int1_t
+       SCF_LEX_WORD_KEY_INT2,      // int2_t
+       SCF_LEX_WORD_KEY_INT3,      // int3_t
+       SCF_LEX_WORD_KEY_INT4,      // int4_t
        SCF_LEX_WORD_KEY_INT16,     // int16_t
        SCF_LEX_WORD_KEY_INT32,     // int32_t
        SCF_LEX_WORD_KEY_INT64,     // int64_t
 
        SCF_LEX_WORD_KEY_UINT8,     // uint8_t
+       SCF_LEX_WORD_KEY_BIT,       // bit
+       SCF_LEX_WORD_KEY_BIT2,      // bit2_t
+       SCF_LEX_WORD_KEY_BIT3,      // bit3_t
+       SCF_LEX_WORD_KEY_BIT4,      // bit4_t
        SCF_LEX_WORD_KEY_UINT16,    // uint16_t
        SCF_LEX_WORD_KEY_UINT32,    // uint32_t
        SCF_LEX_WORD_KEY_UINT64,    // uint64_t

diff --git a/examples/pointer_opt2.c b/examples/pointer_opt2.c
new file mode 100644 (file)
index 0000000..258a5e8
--- /dev/null
+++ b/examples/pointer_opt2.c
@@ -0,0 +1,23 @@
+int printf(const char* fmt, ...);
+
+int f(int i, int a, int b)
+{
+       int*   p;
+       int**  pp  = &p;
+       int*** ppp = &pp;
+
+       p = &a;
+
+       ***ppp += 2;
+       return a;
+}
+
+int main()
+{
+       int i = 1;
+       int a = 2;
+       int b = 3;
+
+       printf("%d\n", f(i, a, b));
+       return 0;
+}

diff --git a/lex/scf_lex.c b/lex/scf_lex.c
index 04caba8ab58d5b120512f13646169cee337e8bb6..abd4f23f9f3b86cdb12b54928e6e88e44ff85b1e 100644 (file)
--- a/lex/scf_lex.c
+++ b/lex/scf_lex.c
@@ -35,8 +35,15 @@ static scf_key_word_t  key_words[] =
        {"float",     SCF_LEX_WORD_KEY_FLOAT},
        {"double",    SCF_LEX_WORD_KEY_DOUBLE},
        {"bit",       SCF_LEX_WORD_KEY_BIT},
+       {"bit2_t",    SCF_LEX_WORD_KEY_BIT2},
+       {"bit3_t",    SCF_LEX_WORD_KEY_BIT3},
+       {"bit4_t",    SCF_LEX_WORD_KEY_BIT4},
 
        {"int8_t",    SCF_LEX_WORD_KEY_INT8},
+       {"int1_t",    SCF_LEX_WORD_KEY_INT1},
+       {"int2_t",    SCF_LEX_WORD_KEY_INT2},
+       {"int3_t",    SCF_LEX_WORD_KEY_INT3},
+       {"int4_t",    SCF_LEX_WORD_KEY_INT4},
        {"int16_t",   SCF_LEX_WORD_KEY_INT16},
        {"int32_t",   SCF_LEX_WORD_KEY_INT32},
        {"int64_t",   SCF_LEX_WORD_KEY_INT64},

diff --git a/native/eda/scf_eda.c b/native/eda/scf_eda.c
index 4544932c1be2060f1515ec8292dad01d5b745226..17c6d20b727cd0cca84efcfa5e2145f82d76e38c 100644 (file)
--- a/native/eda/scf_eda.c
+++ b/native/eda/scf_eda.c
@@ -136,18 +136,6 @@ int scf_eda_select_inst(scf_native_t* ctx, scf_function_t* f)
        if (ret < 0)
                return ret;
 
-       for (l = scf_list_head(&f->dag_list_head); l != scf_list_sentinel(&f->dag_list_head); l = scf_list_next(l)) {
-
-               dn = scf_list_data(l, scf_dag_node_t, list);
-
-               if (dn->var && dn->var->arg_flag) {
-
-                       int i;
-                       for (i = 0; i < dn->n_pins; i++)
-                               dn->pins[i]->flags |= SCF_EDA_PIN_IN;
-               }
-       }
-
 #if 0
        ScfEcomponent* c;
        ScfEpin*       p;

diff --git a/native/eda/scf_eda.h b/native/eda/scf_eda.h
index 8db47238b63df743f22f32831ddfe680d6a472f9..12cbfaa152627ec52f229abe50aa9a42538f040e 100644 (file)
--- a/native/eda/scf_eda.h
+++ b/native/eda/scf_eda.h
@@ -28,11 +28,11 @@ static inline int eda_variable_size(scf_variable_t* v)
 
        if (SCF_VAR_BIT == v->type)
                return 1;
-       if (SCF_VAR_BIT2 == v->type)
+       if (SCF_VAR_U2 == v->type)
                return 2;
-       if (SCF_VAR_BIT3 == v->type)
+       if (SCF_VAR_U3 == v->type)
                return 3;
-       if (SCF_VAR_BIT4 == v->type)
+       if (SCF_VAR_U4 == v->type)
                return 4;
 
        return v->size << 3;

diff --git a/native/eda/scf_eda_inst.c b/native/eda/scf_eda_inst.c
index e6ee7c27b65382c102bb9d84e940347780041f7e..7797ab05383aafa53acca55ba03205fc8c5de863 100644 (file)
--- a/native/eda/scf_eda_inst.c
+++ b/native/eda/scf_eda_inst.c
@@ -111,358 +111,126 @@
 
 static int __eda_bit_nand(scf_function_t* f, ScfEpin** in0, ScfEpin** in1, ScfEpin** out)
 {
-       ScfEcomponent*  B  = f->ef->components[0];
-       ScfEcomponent*  T0 = NULL;
-       ScfEcomponent*  T1 = NULL;
-       ScfEcomponent*  R  = NULL;
-
-       EDA_INST_ADD_COMPONENT(f->ef, T0, SCF_EDA_NPN);
-       EDA_INST_ADD_COMPONENT(f->ef, T1, SCF_EDA_NPN);
-       EDA_INST_ADD_COMPONENT(f->ef, R,  SCF_EDA_Resistor);
-
-       EDA_PIN_ADD_PIN(R,  1,             B,  SCF_EDA_Battery_POS);
-       EDA_PIN_ADD_PIN(T0, SCF_EDA_NPN_C, R,  0);
-       EDA_PIN_ADD_PIN(T0, SCF_EDA_NPN_E, T1, SCF_EDA_NPN_C);
-       EDA_PIN_ADD_PIN(T1, SCF_EDA_NPN_E, B,  SCF_EDA_Battery_NEG);
-
-       *in0 = T0->pins[SCF_EDA_NPN_B];
-       *in1 = T1->pins[SCF_EDA_NPN_B];
-       *out = R ->pins[0];
-       return 0;
-}
+       ScfEcomponent*  B    = f->ef->components[0];
+       ScfEcomponent*  NAND = NULL;
 
-static int __eda_bit_nor(scf_function_t* f, ScfEpin** in0, ScfEpin** in1, ScfEpin** out)
-{
-       ScfEcomponent*  B  = f->ef->components[0];
-       ScfEcomponent*  T0 = NULL;
-       ScfEcomponent*  T1 = NULL;
-       ScfEcomponent*  R  = NULL;
-
-       EDA_INST_ADD_COMPONENT(f->ef, T0, SCF_EDA_NPN);
-       EDA_INST_ADD_COMPONENT(f->ef, T1, SCF_EDA_NPN);
-       EDA_INST_ADD_COMPONENT(f->ef, R,  SCF_EDA_Resistor);
-
-       EDA_PIN_ADD_PIN(R,  1,             B,  SCF_EDA_Battery_POS);
-       EDA_PIN_ADD_PIN(T0, SCF_EDA_NPN_C, R,  0);
-       EDA_PIN_ADD_PIN(T1, SCF_EDA_NPN_C, R,  0);
-       EDA_PIN_ADD_PIN(T0, SCF_EDA_NPN_E, B,  SCF_EDA_Battery_NEG);
-       EDA_PIN_ADD_PIN(T1, SCF_EDA_NPN_E, B,  SCF_EDA_Battery_NEG);
-
-       *in0 = T0->pins[SCF_EDA_NPN_B];
-       *in1 = T1->pins[SCF_EDA_NPN_B];
-       *out = R ->pins[0];
+       EDA_INST_ADD_COMPONENT(f->ef, NAND, SCF_EDA_NAND);
+
+       EDA_PIN_ADD_PIN(NAND, SCF_EDA_NAND_POS, B, SCF_EDA_Battery_POS);
+       EDA_PIN_ADD_PIN(NAND, SCF_EDA_NAND_NEG, B, SCF_EDA_Battery_NEG);
+
+       *in0 = NAND->pins[SCF_EDA_NAND_IN0];
+       *in1 = NAND->pins[SCF_EDA_NAND_IN1];
+       *out = NAND->pins[SCF_EDA_NAND_OUT];
        return 0;
 }
 
 static int __eda_bit_not(scf_function_t* f, ScfEpin** in, ScfEpin** out)
 {
-       ScfEcomponent*  B = f->ef->components[0];
-       ScfEcomponent*  T = NULL;
-       ScfEcomponent*  R = NULL;
+       ScfEcomponent*  B   = f->ef->components[0];
+       ScfEcomponent*  NOT = NULL;
 
-       EDA_INST_ADD_COMPONENT(f->ef, R,  SCF_EDA_Resistor);
-       EDA_INST_ADD_COMPONENT(f->ef, T,  SCF_EDA_NPN);
+       EDA_INST_ADD_COMPONENT(f->ef, NOT, SCF_EDA_NOT);
 
-       EDA_PIN_ADD_PIN(R, 1,             B, SCF_EDA_Battery_POS);
-       EDA_PIN_ADD_PIN(T, SCF_EDA_NPN_C, R, 0);
-       EDA_PIN_ADD_PIN(T, SCF_EDA_NPN_E, B, SCF_EDA_Battery_NEG);
+       EDA_PIN_ADD_PIN(NOT, SCF_EDA_NOT_POS, B, SCF_EDA_Battery_POS);
+       EDA_PIN_ADD_PIN(NOT, SCF_EDA_NOT_NEG, B, SCF_EDA_Battery_NEG);
 
-       *in  = T->pins[SCF_EDA_NPN_B];
-       *out = R->pins[0];
+       *in  = NOT->pins[SCF_EDA_NOT_IN];
+       *out = NOT->pins[SCF_EDA_NOT_OUT];
        return 0;
 }
 
 static int __eda_bit_and(scf_function_t* f, ScfEpin** in0, ScfEpin** in1, ScfEpin** out)
 {
-       ScfEpin* nad0 = NULL;
-       ScfEpin* nad1 = NULL;
-       ScfEpin* nad_ = NULL;
-
-       ScfEpin* not0 = NULL;
-       ScfEpin* not_ = NULL;
-
-       int ret = __eda_bit_nand(f, &nad0, &nad1, &nad_);
-       if (ret < 0)
-               return ret;
+       ScfEcomponent*  B   = f->ef->components[0];
+       ScfEcomponent*  AND = NULL;
 
-       ret = __eda_bit_not(f, &not0, &not_);
-       if (ret < 0)
-               return ret;
+       EDA_INST_ADD_COMPONENT(f->ef, AND, SCF_EDA_AND);
 
-       EDA_PIN_ADD_PIN_EF(f->ef, not0, nad_);
+       EDA_PIN_ADD_PIN(AND, SCF_EDA_AND_POS, B, SCF_EDA_Battery_POS);
+       EDA_PIN_ADD_PIN(AND, SCF_EDA_AND_NEG, B, SCF_EDA_Battery_NEG);
 
-       *in0 = nad0;
-       *in1 = nad1;
-       *out = not_;
+       *in0 = AND->pins[SCF_EDA_AND_IN0];
+       *in1 = AND->pins[SCF_EDA_AND_IN1];
+       *out = AND->pins[SCF_EDA_AND_OUT];
        return 0;
 }
 
 static int __eda_bit_or(scf_function_t* f, ScfEpin** in0, ScfEpin** in1, ScfEpin** out)
 {
-       ScfEpin* nor0 = NULL;
-       ScfEpin* nor1 = NULL;
-       ScfEpin* nor_ = NULL;
-
-       ScfEpin* not0 = NULL;
-       ScfEpin* not_ = NULL;
-
-       int ret = __eda_bit_nor(f, &nor0, &nor1, &nor_);
-       if (ret < 0)
-               return ret;
+       ScfEcomponent*  B  = f->ef->components[0];
+       ScfEcomponent*  OR = NULL;
 
-       ret = __eda_bit_not(f, &not0, &not_);
-       if (ret < 0)
-               return ret;
+       EDA_INST_ADD_COMPONENT(f->ef, OR, SCF_EDA_OR);
 
-       EDA_PIN_ADD_PIN_EF(f->ef, not0, nor_);
+       EDA_PIN_ADD_PIN(OR, SCF_EDA_OR_POS, B, SCF_EDA_Battery_POS);
+       EDA_PIN_ADD_PIN(OR, SCF_EDA_OR_NEG, B, SCF_EDA_Battery_NEG);
 
-       *in0 = nor0;
-       *in1 = nor1;
-       *out = not_;
+       *in0 = OR->pins[SCF_EDA_OR_IN0];
+       *in1 = OR->pins[SCF_EDA_OR_IN1];
+       *out = OR->pins[SCF_EDA_OR_OUT];
        return 0;
 }
 
-/*
-   x + y =   ~(x &    y)  &   ( x |  y)
-   x + y =    (x NAND y)  &  ~(~x & ~y)
-   x + y =    (x NAND y)  &   (~x NAND ~y)
-   x + y =  ~((x NAND y) NAND (~x NAND ~y))
-
-   x + y =   ~(x &    y)  &  (x | y)
-   x + y =    (x NAND y)  &  (x | y)
-   x + y = ~(~(x NAND y)  | ~(x | y))
-   x + y =   ~(x NAND y) NOR (x NOR y))
-   cf    =   ~(x NAND y)
- */
-static int __eda_bit_add(scf_function_t* f, ScfEpin** in0, ScfEpin** in1, ScfEpin** out, ScfEpin** cf)
+static int __eda_bit_xor(scf_function_t* f, ScfEpin** in0, ScfEpin** in1, ScfEpin** out)
 {
-       ScfEpin* nad0 = NULL;
-       ScfEpin* nad1 = NULL;
-       ScfEpin* nad_ = NULL;
-
-       ScfEpin* not  = NULL;
-       ScfEpin* cf_  = NULL;
+       ScfEcomponent*  B   = f->ef->components[0];
+       ScfEcomponent*  XOR = NULL;
 
-       ScfEpin* nor0 = NULL;
-       ScfEpin* nor1 = NULL;
-       ScfEpin* nor_ = NULL;
+       EDA_INST_ADD_COMPONENT(f->ef, XOR, SCF_EDA_XOR);
 
-       ScfEpin* nor2 = NULL;
-       ScfEpin* nor3 = NULL;
-       ScfEpin* out_ = NULL;
+       EDA_PIN_ADD_PIN(XOR, SCF_EDA_XOR_POS, B, SCF_EDA_Battery_POS);
+       EDA_PIN_ADD_PIN(XOR, SCF_EDA_XOR_NEG, B, SCF_EDA_Battery_NEG);
 
-       int ret = __eda_bit_nand(f, &nad0, &nad1, &nad_);
-       if (ret < 0)
-               return ret;
+       *in0 = XOR->pins[SCF_EDA_XOR_IN0];
+       *in1 = XOR->pins[SCF_EDA_XOR_IN1];
+       *out = XOR->pins[SCF_EDA_XOR_OUT];
+       return 0;
+}
 
-       ret = __eda_bit_not(f, &not, &cf_);
-       if (ret < 0)
-               return ret;
-       EDA_PIN_ADD_PIN_EF(f->ef, not, nad_);
+static int __eda_bit_add(scf_function_t* f, ScfEpin** in0, ScfEpin** in1, ScfEpin** out, ScfEpin** cf)
+{
+       ScfEpin* and0 = NULL;
+       ScfEpin* and1 = NULL;
 
-       ret = __eda_bit_nor(f, &nor0, &nor1, &nor_);
+       int ret = __eda_bit_xor(f, in0, in1, out);
        if (ret < 0)
                return ret;
-       EDA_PIN_ADD_PIN_EF(f->ef, nor0, nad0);
-       EDA_PIN_ADD_PIN_EF(f->ef, nor1, nad1);
 
-       ret = __eda_bit_nor(f, &nor2, &nor3, &out_);
+       ret = __eda_bit_and(f, &and0, &and1, cf);
        if (ret < 0)
                return ret;
-       EDA_PIN_ADD_PIN_EF(f->ef, nor2, cf_);
-       EDA_PIN_ADD_PIN_EF(f->ef, nor3, nor_);
 
-       *in0 = nad0;
-       *in1 = nad1;
-       *out = out_;
-       *cf  = cf_;
+       EDA_PIN_ADD_PIN_EF(f->ef, and0, *in0);
+       EDA_PIN_ADD_PIN_EF(f->ef, and1, *in1);
        return 0;
 }
 
 static int __eda_bit_adc(scf_function_t* f, ScfEpin** in0, ScfEpin** in1, ScfEpin** in2, ScfEpin** out, ScfEpin** cf)
 {
-       ScfEcomponent*  B  = f->ef->components[0];
-       ScfEcomponent*  R0 = NULL;
-       ScfEcomponent*  R1 = NULL;
-       ScfEcomponent*  R2 = NULL;
-       ScfEcomponent*  R3 = NULL;
-       ScfEcomponent*  R4 = NULL;
-
-       ScfEcomponent*  T0 = NULL;
-       ScfEcomponent*  T1 = NULL;
-
-       ScfEcomponent*  T2 = NULL;
-       ScfEcomponent*  T3 = NULL;
-       ScfEcomponent*  T4 = NULL;
-       ScfEcomponent*  T5 = NULL;
-       ScfEcomponent*  T6 = NULL;
-
-       ScfEcomponent*  T7 = NULL;
-
-       ScfEcomponent*  T8 = NULL;
-       ScfEcomponent*  T9 = NULL;
-
-       ScfEcomponent*  T10 = NULL;
-       ScfEcomponent*  T11 = NULL;
-       ScfEcomponent*  T12 = NULL;
+       ScfEpin* out0 = NULL;
+       ScfEpin* cf0  = NULL;
 
-       // T0: 0, T1: 1
-       EDA_INST_ADD_COMPONENT(f->ef, R0, SCF_EDA_Resistor);
-       EDA_INST_ADD_COMPONENT(f->ef, T0, SCF_EDA_NPN);
-       EDA_INST_ADD_COMPONENT(f->ef, T1, SCF_EDA_NPN);
-
-       EDA_PIN_ADD_PIN(R0, 1,             B,  SCF_EDA_Battery_POS);
-       EDA_PIN_ADD_PIN(T0, SCF_EDA_NPN_C, R0, 0);
-       EDA_PIN_ADD_PIN(T1, SCF_EDA_NPN_C, T0, SCF_EDA_NPN_E);
-
-       // T2: 1, T3: 2, T4: 0, T5: 1, T6: 0
-       EDA_INST_ADD_COMPONENT(f->ef, R1, SCF_EDA_Resistor);
-       EDA_INST_ADD_COMPONENT(f->ef, T2, SCF_EDA_NPN);
-       EDA_INST_ADD_COMPONENT(f->ef, T3, SCF_EDA_NPN);
-       EDA_INST_ADD_COMPONENT(f->ef, T4, SCF_EDA_NPN);
-       EDA_INST_ADD_COMPONENT(f->ef, T5, SCF_EDA_NPN);
-       EDA_INST_ADD_COMPONENT(f->ef, T6, SCF_EDA_NPN);
-
-       EDA_PIN_ADD_PIN(R1, 1,             B,  SCF_EDA_Battery_POS);
-       EDA_PIN_ADD_PIN(T2, SCF_EDA_NPN_C, R1, 0);
-       EDA_PIN_ADD_PIN(T3, SCF_EDA_NPN_C, T2, SCF_EDA_NPN_E);
-       EDA_PIN_ADD_PIN(T3, SCF_EDA_NPN_E, B,  SCF_EDA_Battery_NEG);
-
-       EDA_PIN_ADD_PIN(T4, SCF_EDA_NPN_C, R1, 0);
-       EDA_PIN_ADD_PIN(T4, SCF_EDA_NPN_E, T2, SCF_EDA_NPN_E);
-
-       EDA_PIN_ADD_PIN(T5, SCF_EDA_NPN_C, R1, 0);
-       EDA_PIN_ADD_PIN(T6, SCF_EDA_NPN_C, T5, SCF_EDA_NPN_E);
-       EDA_PIN_ADD_PIN(T6, SCF_EDA_NPN_E, B,  SCF_EDA_Battery_NEG);
-
-       // T1: e
-       EDA_PIN_ADD_PIN(T1, SCF_EDA_NPN_E, T2, SCF_EDA_NPN_E);
-
-       // T7: cf
-       EDA_INST_ADD_COMPONENT(f->ef, R2, SCF_EDA_Resistor);
-       EDA_INST_ADD_COMPONENT(f->ef, T7, SCF_EDA_NPN);
-
-       EDA_PIN_ADD_PIN(R2, 1,             B,  SCF_EDA_Battery_POS);
-       EDA_PIN_ADD_PIN(T7, SCF_EDA_NPN_C, R2, 0);
-       EDA_PIN_ADD_PIN(T7, SCF_EDA_NPN_E, B,  SCF_EDA_Battery_NEG);
-       EDA_PIN_ADD_PIN(T7, SCF_EDA_NPN_B, R1, 0);
-
-       // T8, T9: out
-       EDA_INST_ADD_COMPONENT(f->ef, R3, SCF_EDA_Resistor);
-       EDA_INST_ADD_COMPONENT(f->ef, T8, SCF_EDA_NPN);
-       EDA_INST_ADD_COMPONENT(f->ef, T9, SCF_EDA_NPN);
-
-       EDA_PIN_ADD_PIN(R3, 1,             B,  SCF_EDA_Battery_POS);
-       EDA_PIN_ADD_PIN(T8, SCF_EDA_NPN_C, R3, 0);
-       EDA_PIN_ADD_PIN(T8, SCF_EDA_NPN_E, R1, 0);
-       EDA_PIN_ADD_PIN(T8, SCF_EDA_NPN_B, R0, 0);
-
-       EDA_PIN_ADD_PIN(T9, SCF_EDA_NPN_C, R3, 0);
-       EDA_PIN_ADD_PIN(T9, SCF_EDA_NPN_E, B,  SCF_EDA_Battery_NEG);
-
-       // T10: 1, T11: 0, T12: 2
-       EDA_INST_ADD_COMPONENT(f->ef, R4,  SCF_EDA_Resistor);
-       EDA_INST_ADD_COMPONENT(f->ef, T10, SCF_EDA_NPN);
-       EDA_INST_ADD_COMPONENT(f->ef, T11, SCF_EDA_NPN);
-       EDA_INST_ADD_COMPONENT(f->ef, T12, SCF_EDA_NPN);
-
-       EDA_PIN_ADD_PIN(R4,  1,             B,  SCF_EDA_Battery_POS);
-       EDA_PIN_ADD_PIN(T10, SCF_EDA_NPN_C, R4, 0);
-       EDA_PIN_ADD_PIN(T11, SCF_EDA_NPN_C, R4, 0);
-       EDA_PIN_ADD_PIN(T12, SCF_EDA_NPN_C, R4, 0);
-
-       EDA_PIN_ADD_PIN(T10, SCF_EDA_NPN_E, B,  SCF_EDA_Battery_NEG);
-       EDA_PIN_ADD_PIN(T11, SCF_EDA_NPN_E, B,  SCF_EDA_Battery_NEG);
-       EDA_PIN_ADD_PIN(T12, SCF_EDA_NPN_E, B,  SCF_EDA_Battery_NEG);
-
-       // T9: b
-       EDA_PIN_ADD_PIN(T9,  SCF_EDA_NPN_B, R4, 0);
-
-       // 0: T0, T4, T6, T11
-       EDA_PIN_ADD_PIN(T0, SCF_EDA_NPN_B, T4,  SCF_EDA_NPN_B);
-       EDA_PIN_ADD_PIN(T0, SCF_EDA_NPN_B, T6,  SCF_EDA_NPN_B);
-       EDA_PIN_ADD_PIN(T0, SCF_EDA_NPN_B, T11, SCF_EDA_NPN_B);
-
-       // 1: T1, T2, T5, T10
-       EDA_PIN_ADD_PIN(T1, SCF_EDA_NPN_B, T2,  SCF_EDA_NPN_B);
-       EDA_PIN_ADD_PIN(T1, SCF_EDA_NPN_B, T5,  SCF_EDA_NPN_B);
-       EDA_PIN_ADD_PIN(T1, SCF_EDA_NPN_B, T10, SCF_EDA_NPN_B);
-
-       // 2: T3, T12
-       EDA_PIN_ADD_PIN(T3, SCF_EDA_NPN_B, T12, SCF_EDA_NPN_B);
-
-       *in0 = T0->pins[SCF_EDA_NPN_B];
-       *in1 = T1->pins[SCF_EDA_NPN_B];
-       *in2 = T3->pins[SCF_EDA_NPN_B];
-       *out = R3->pins[0];
-       *cf  = R2->pins[0];
-       return 0;
-}
+       ScfEpin* in3  = NULL;
+       ScfEpin* cf1  = NULL;
 
-static int __eda_bit_sub0(scf_function_t* f, ScfEpin** in0, ScfEpin** in1, ScfEpin** out, ScfEpin** cf)
-{
-       ScfEcomponent*  B  = f->ef->components[0];
-       ScfEcomponent*  R0 = NULL;
-       ScfEcomponent*  R1 = NULL;
-       ScfEcomponent*  R2 = NULL;
-       ScfEcomponent*  R3 = NULL;
+       ScfEpin* or0  = NULL;
+       ScfEpin* or1  = NULL;
 
-       ScfEcomponent*  T0 = NULL;
-       ScfEcomponent*  T1 = NULL;
-       ScfEcomponent*  T2 = NULL;
-       ScfEcomponent*  T3 = NULL;
+       int ret = __eda_bit_add(f, in0, in1, &out0, &cf0);
+       if (ret < 0)
+               return ret;
 
-       ScfEcomponent*  T4 = NULL;
-       ScfEcomponent*  T5 = NULL;
+       ret = __eda_bit_add(f, in2, &in3, out, &cf1);
+       if (ret < 0)
+               return ret;
+       EDA_PIN_ADD_PIN_EF(f->ef, out0, in3);
 
-       // T0: 0, T1: 1
-       EDA_INST_ADD_COMPONENT(f->ef, R0, SCF_EDA_Resistor);
-       EDA_INST_ADD_COMPONENT(f->ef, T0, SCF_EDA_NPN);
-       EDA_INST_ADD_COMPONENT(f->ef, T1, SCF_EDA_NPN);
-
-       EDA_PIN_ADD_PIN(R0, 1,             B,  SCF_EDA_Battery_POS);
-       EDA_PIN_ADD_PIN(T0, SCF_EDA_NPN_C, R0, 0);
-       EDA_PIN_ADD_PIN(T1, SCF_EDA_NPN_C, T0, SCF_EDA_NPN_E);
-       EDA_PIN_ADD_PIN(T1, SCF_EDA_NPN_E, B,  SCF_EDA_Battery_NEG);
-
-       // T2: 1, T3: 0
-       EDA_INST_ADD_COMPONENT(f->ef, R1, SCF_EDA_Resistor);
-       EDA_INST_ADD_COMPONENT(f->ef, T2, SCF_EDA_NPN);
-       EDA_INST_ADD_COMPONENT(f->ef, T3, SCF_EDA_NPN);
-
-       EDA_PIN_ADD_PIN(R1, 1,             B,  SCF_EDA_Battery_POS);
-       EDA_PIN_ADD_PIN(T2, SCF_EDA_NPN_C, R1, 0);
-       EDA_PIN_ADD_PIN(T3, SCF_EDA_NPN_C, R1, 0);
-       EDA_PIN_ADD_PIN(T2, SCF_EDA_NPN_E, T3, SCF_EDA_NPN_E);
-       EDA_PIN_ADD_PIN(T2, SCF_EDA_NPN_E, B,  SCF_EDA_Battery_NEG);
-
-       // cf
-       EDA_INST_ADD_COMPONENT(f->ef, R2, SCF_EDA_Resistor);
-       EDA_INST_ADD_COMPONENT(f->ef, T4, SCF_EDA_NPN);
-
-       EDA_PIN_ADD_PIN(R2, 1,             B,  SCF_EDA_Battery_POS);
-       EDA_PIN_ADD_PIN(T4, SCF_EDA_NPN_C, R2, 0);
-       EDA_PIN_ADD_PIN(T4, SCF_EDA_NPN_E, B,  SCF_EDA_Battery_NEG);
-       EDA_PIN_ADD_PIN(T4, SCF_EDA_NPN_B, R1, 0);
-
-       // out
-       EDA_INST_ADD_COMPONENT(f->ef, R3, SCF_EDA_Resistor);
-       EDA_INST_ADD_COMPONENT(f->ef, T5, SCF_EDA_NPN);
-
-       EDA_PIN_ADD_PIN(R3, 1,             B,  SCF_EDA_Battery_POS);
-       EDA_PIN_ADD_PIN(T5, SCF_EDA_NPN_C, R3, 0);
-       EDA_PIN_ADD_PIN(T5, SCF_EDA_NPN_E, R1, 0);
-       EDA_PIN_ADD_PIN(T5, SCF_EDA_NPN_B, R0, 0);
-
-       // 0: T0, T3
-       // 1: T1, T2
-       EDA_PIN_ADD_PIN(T0, SCF_EDA_NPN_B, T3, SCF_EDA_NPN_B);
-       EDA_PIN_ADD_PIN(T1, SCF_EDA_NPN_B, T2, SCF_EDA_NPN_B);
-
-       *in0 = T0->pins[SCF_EDA_NPN_B];
-       *in1 = T1->pins[SCF_EDA_NPN_B];
-       *out = R3->pins[0];
-       *cf  = R2->pins[0];
+       ret = __eda_bit_or(f, &or0, &or1, cf);
+       if (ret < 0)
+               return ret;
+       EDA_PIN_ADD_PIN_EF(f->ef, or0,  cf0);
+       EDA_PIN_ADD_PIN_EF(f->ef, or1,  cf1);
        return 0;
 }
 
@@ -482,7 +250,6 @@ static int _eda_inst_bit_not_handler(scf_native_t* ctx, scf_3ac_code_t* c)
        out->n_pins = N;
 
        for (i = 0; i < N; i++) {
-
                ScfEpin* pi = NULL;
                ScfEpin* po = NULL;
 
@@ -492,8 +259,12 @@ static int _eda_inst_bit_not_handler(scf_native_t* ctx, scf_3ac_code_t* c)
 
                EDA_PIN_ADD_INPUT(in, i, f->ef, pi);
 
+               if (in->var->arg_flag) {
+                       in->pins[i]->flags |= SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0;
+                       in->pins[i]->io_lid = i;
+               }
+
                out->pins[i] = po;
-               in ->pins[i]->flags |= SCF_EDA_PIN_IN0;
        }
 
        return 0;
@@ -530,8 +301,17 @@ static int _eda_inst_bit_and_handler(scf_native_t* ctx, scf_3ac_code_t* c)
                EDA_PIN_ADD_INPUT(in0, i, f->ef, p0);
                EDA_PIN_ADD_INPUT(in1, i, f->ef, p1);
 
+               if (in0->var->arg_flag) {
+                       in0->pins[i]->flags |= SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0;
+                       in0->pins[i]->io_lid = i;
+               }
+
+               if (in1->var->arg_flag) {
+                       in1->pins[i]->flags |= SCF_EDA_PIN_IN;
+                       in1->pins[i]->io_lid = i;
+               }
+
                out->pins[i] = po;
-               in0->pins[i]->flags |= SCF_EDA_PIN_IN0;
        }
 
        return 0;
@@ -568,8 +348,264 @@ static int _eda_inst_bit_or_handler(scf_native_t* ctx, scf_3ac_code_t* c)
                EDA_PIN_ADD_INPUT(in0, i, f->ef, p0);
                EDA_PIN_ADD_INPUT(in1, i, f->ef, p1);
 
+               if (in0->var->arg_flag) {
+                       in0->pins[i]->flags |= SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0;
+                       in0->pins[i]->io_lid = i;
+               }
+
+               if (in1->var->arg_flag) {
+                       in1->pins[i]->flags |= SCF_EDA_PIN_IN;
+                       in1->pins[i]->io_lid = i;
+               }
+
                out->pins[i] = po;
-               in0->pins[i]->flags |= SCF_EDA_PIN_IN0;
+       }
+
+       return 0;
+}
+
+static int _eda_inst_shl_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+       EDA_INST_OP3_CHECK()
+
+       scf_dag_node_t* src = src0->dag_node;
+       scf_dag_node_t* sht = src1->dag_node;
+       scf_dag_node_t* out = dst ->dag_node;
+       ScfEcomponent*  B   = f->ef->components[0];
+
+       int i;
+       int j;
+       int N = eda_variable_size(src->var);
+
+       EDA_INST_IN_CHECK(src, N);
+       EDA_INST_IN_CHECK(sht, N);
+
+       src->n_pins = N;
+       sht->n_pins = N;
+       out->n_pins = N;
+
+       ScfEpin* res[SCF_EDA_MAX_BITS];
+       ScfEpin* tmp[SCF_EDA_MAX_BITS];
+
+       for (j = 0; j < N && j < 6; j++) {
+               ScfEpin* p1 = NULL;
+               ScfEpin* p2 = NULL;
+
+               int ret = __eda_bit_not(f, &p1, &p2);
+               if (ret < 0)
+                       return ret;
+               EDA_PIN_ADD_INPUT(sht, j, f->ef, p1);
+
+               for (i = 0; i < (1 << j); i++) {
+                       ScfEpin* p00 = NULL;
+                       ScfEpin* p01 = NULL;
+                       ScfEpin* po = NULL;
+
+                       ret = __eda_bit_and(f, &p00, &p01, &po);
+                       if (ret < 0)
+                               return ret;
+                       EDA_PIN_ADD_PIN_EF(f->ef, p01, p2);
+
+                       if (j > 0)
+                               EDA_PIN_ADD_PIN_EF(f->ef, p00, res[i]);
+                       else
+                               EDA_PIN_ADD_INPUT(src, i, f->ef, p00);
+
+                       tmp[i] = po;
+               }
+
+               for ( ; i < N; i++) {
+                       ScfEpin* p00 = NULL;
+                       ScfEpin* p01 = NULL;
+                       ScfEpin* po0 = NULL;
+
+                       ScfEpin* p10 = NULL;
+                       ScfEpin* p11 = NULL;
+                       ScfEpin* po1 = NULL;
+
+                       ScfEpin* p20 = NULL;
+                       ScfEpin* p21 = NULL;
+                       ScfEpin* po  = NULL;
+/*
+x = sht[j]
+y = src[i - (1 << j)]
+z = src[i]
+
+out[i] =     (x & y) |   (~x & z)
+       =  ~(~(x & y) &  ~(~x & z))
+       = (x NAND y) NAND (~x NAND z)
+ */
+                       ret = __eda_bit_nand(f, &p00, &p10, &po0);
+                       if (ret < 0)
+                               return ret;
+
+                       ret = __eda_bit_nand(f, &p01, &p11, &po1);
+                       if (ret < 0)
+                               return ret;
+
+                       ret = __eda_bit_nand(f, &p20, &p21, &po);
+                       if (ret < 0)
+                               return ret;
+
+                       EDA_PIN_ADD_PIN_EF(f->ef, p10, p2);
+                       EDA_PIN_ADD_PIN_EF(f->ef, p11, p1);
+
+                       EDA_PIN_ADD_PIN_EF(f->ef, p20, po0);
+                       EDA_PIN_ADD_PIN_EF(f->ef, p21, po1);
+
+                       if (j > 0) {
+                               EDA_PIN_ADD_PIN_EF(f->ef, p00, res[i]);
+                               EDA_PIN_ADD_PIN_EF(f->ef, p01, res[i - (1 << j)]);
+                       } else {
+                               EDA_PIN_ADD_INPUT(src, i,            f->ef, p00);
+                               EDA_PIN_ADD_INPUT(src, i - (1 << j), f->ef, p01);
+                       }
+
+                       tmp[i] = po;
+               }
+
+               for (i = 0; i < N; i++) {
+                       res[i] = tmp[i];
+                       tmp[i] = NULL;
+               }
+       }
+
+       for (i = 0; i < N; i++) {
+               if (src->var->arg_flag) {
+                       src->pins[i]->flags |= SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0;
+                       src->pins[i]->io_lid = i;
+               }
+
+               if (sht->var->arg_flag) {
+                       sht->pins[i]->flags |= SCF_EDA_PIN_IN;
+                       sht->pins[i]->io_lid = i;
+               }
+
+               out->pins[i] = res[i];
+       }
+
+       return 0;
+}
+
+static int _eda_inst_shr_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+       EDA_INST_OP3_CHECK()
+
+       scf_dag_node_t* src = src0->dag_node;
+       scf_dag_node_t* sht = src1->dag_node;
+       scf_dag_node_t* out = dst ->dag_node;
+       ScfEcomponent*  B   = f->ef->components[0];
+
+       int i;
+       int j;
+       int N    = eda_variable_size  (src->var);
+       int sign = scf_variable_signed(src->var);
+
+       EDA_INST_IN_CHECK(src, N);
+       EDA_INST_IN_CHECK(sht, N);
+
+       src->n_pins = N;
+       sht->n_pins = N;
+       out->n_pins = N;
+
+       ScfEpin* res[SCF_EDA_MAX_BITS];
+       ScfEpin* tmp[SCF_EDA_MAX_BITS];
+
+       for (j = 0; j < N && j < 6; j++) {
+               ScfEpin* p1 = NULL;
+               ScfEpin* p2 = NULL;
+
+               int ret = __eda_bit_not(f, &p1, &p2);
+               if (ret < 0)
+                       return ret;
+               EDA_PIN_ADD_INPUT(sht, j, f->ef, p1);
+
+               for (i = 0; i < N; i++) {
+                       ScfEpin* p00 = NULL;
+                       ScfEpin* p01 = NULL;
+                       ScfEpin* po0 = NULL;
+
+                       ScfEpin* p10 = NULL;
+                       ScfEpin* p11 = NULL;
+                       ScfEpin* po1 = NULL;
+
+                       ScfEpin* p20 = NULL;
+                       ScfEpin* p21 = NULL;
+                       ScfEpin* po  = NULL;
+/*
+x = sht[j]
+y = src[i + (1 << j)]
+z = src[i]
+
+out[i] =     (x & y) |   (~x & z)
+       =  ~(~(x & y) &  ~(~x & z))
+       = (x NAND y) NAND (~x NAND z)
+ */
+
+                       if (i >= N - (1 << j) && !sign) {
+
+                               ret = __eda_bit_and(f, &p00, &p10, &po);
+                               if (ret < 0)
+                                       return ret;
+                               EDA_PIN_ADD_PIN_EF(f->ef, p10, p2);
+
+                       } else {
+                               ret = __eda_bit_nand(f, &p00, &p10, &po0);
+                               if (ret < 0)
+                                       return ret;
+
+                               ret = __eda_bit_nand(f, &p01, &p11, &po1);
+                               if (ret < 0)
+                                       return ret;
+
+                               ret = __eda_bit_nand(f, &p20, &p21, &po);
+                               if (ret < 0)
+                                       return ret;
+
+                               EDA_PIN_ADD_PIN_EF(f->ef, p10, p2);
+                               EDA_PIN_ADD_PIN_EF(f->ef, p11, p1);
+
+                               EDA_PIN_ADD_PIN_EF(f->ef, p21, po1);
+                               EDA_PIN_ADD_PIN_EF(f->ef, p20, po0);
+
+                               int k = i + (1 << j);
+                               if (k >= N)
+                                       k =  N - 1;
+
+                               scf_logi("sign: %d, j: %d, i: %d, k: %d\n", sign, j, i, k);
+
+                               if (j > 0)
+                                       EDA_PIN_ADD_PIN_EF(f->ef, p01, res[k]);
+                               else
+                                       EDA_PIN_ADD_INPUT(src, k, f->ef, p01);
+                       }
+
+                       if (j > 0)
+                               EDA_PIN_ADD_PIN_EF(f->ef, p00, res[i]);
+                       else
+                               EDA_PIN_ADD_INPUT(src, i, f->ef, p00);
+
+                       tmp[i] = po;
+               }
+
+               for (i = 0; i < N; i++) {
+                       res[i] = tmp[i];
+                       tmp[i] = NULL;
+               }
+       }
+
+       for (i = 0; i < N; i++) {
+               if (src->var->arg_flag) {
+                       src->pins[i]->flags |= SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0;
+                       src->pins[i]->io_lid = i;
+               }
+
+               if (sht->var->arg_flag) {
+                       sht->pins[i]->flags |= SCF_EDA_PIN_IN;
+                       sht->pins[i]->io_lid = i;
+               }
+
+               out->pins[i] = res[i];
        }
 
        return 0;
@@ -623,8 +659,17 @@ static int _eda_inst_add_handler(scf_native_t* ctx, scf_3ac_code_t* c)
                pc         = cf; // carry flag
                cf->flags |= SCF_EDA_PIN_CF;
 
+               if (in0->var->arg_flag) {
+                       in0->pins[i]->flags |= SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0;
+                       in0->pins[i]->io_lid = i;
+               }
+
+               if (in1->var->arg_flag) {
+                       in1->pins[i]->flags |= SCF_EDA_PIN_IN;
+                       in1->pins[i]->io_lid = i;
+               }
+
                out->pins[i] = res; // result
-               in0->pins[i]->flags |= SCF_EDA_PIN_IN0;
        }
 
        return 0;
@@ -639,6 +684,7 @@ static int _eda_inst_sub_handler(scf_native_t* ctx, scf_3ac_code_t* c)
        scf_dag_node_t* out = dst ->dag_node;
 
        ScfEcomponent*  B   = f->ef->components[0];
+       ScfEcomponent*  R0  = NULL;
        ScfEpin*        pc  = NULL;
 
        int i;
@@ -651,6 +697,11 @@ static int _eda_inst_sub_handler(scf_native_t* ctx, scf_3ac_code_t* c)
        in1->n_pins = N;
        out->n_pins = N;
 
+       EDA_INST_ADD_COMPONENT(f->ef, R0, SCF_EDA_Resistor);
+
+       EDA_PIN_ADD_PIN(R0, 1, B, SCF_EDA_Battery_POS);
+       pc = R0->pins[0];
+
        for (i = 0; i < N; i++) {
 
                ScfEpin* p0  = NULL;
@@ -665,19 +716,11 @@ static int _eda_inst_sub_handler(scf_native_t* ctx, scf_3ac_code_t* c)
                if (ret < 0)
                        return ret;
 
-               if (i > 0) {
-                       ret = __eda_bit_adc(f, &p0, &p2, &p3, &res, &cf);
-                       if (ret < 0)
-                               return ret;
-
-                       EDA_PIN_ADD_PIN_EF(f->ef, p3, pc);
-               } else {
-                       ret = __eda_bit_sub0(f, &p0, &p2, &res, &cf);
-                       if (ret < 0)
-                               return ret;
-               }
-
+               ret = __eda_bit_adc(f, &p0, &p2, &p3, &res, &cf);
+               if (ret < 0)
+                       return ret;
                EDA_PIN_ADD_PIN_EF(f->ef, p2, not);
+               EDA_PIN_ADD_PIN_EF(f->ef, p3, pc);
 
                EDA_PIN_ADD_INPUT(in0, i, f->ef, p0);
                EDA_PIN_ADD_INPUT(in1, i, f->ef, p1);
@@ -685,8 +728,17 @@ static int _eda_inst_sub_handler(scf_native_t* ctx, scf_3ac_code_t* c)
                pc         = cf;
                cf->flags |= SCF_EDA_PIN_CF;
 
+               if (in0->var->arg_flag) {
+                       in0->pins[i]->flags |= SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0;
+                       in0->pins[i]->io_lid = i;
+               }
+
+               if (in1->var->arg_flag) {
+                       in1->pins[i]->flags |= SCF_EDA_PIN_IN;
+                       in1->pins[i]->io_lid = i;
+               }
+
                out->pins[i] = res;
-               in0->pins[i]->flags |= SCF_EDA_PIN_IN0;
        }
 
        return 0;
@@ -694,91 +746,26 @@ static int _eda_inst_sub_handler(scf_native_t* ctx, scf_3ac_code_t* c)
 
 static int __eda_bit_mla(scf_function_t* f, ScfEpin** a, ScfEpin** b, ScfEpin** c, ScfEpin** d, ScfEpin** out, ScfEpin** cf)
 {
-       ScfEcomponent* B  = f->ef->components[0];
-       ScfEcomponent* R0 = NULL;
-       ScfEcomponent* T0 = NULL;
-       ScfEcomponent* T1 = NULL;
-
-       ScfEpin* a0   = NULL;
-       ScfEpin* b0   = NULL;
-       ScfEpin* ab0  = NULL;
-
-       ScfEpin* c0   = NULL;
-       ScfEpin* d0   = NULL;
-       ScfEpin* cd0  = NULL;
-
-       ScfEpin* ab1  = NULL;
-       ScfEpin* cd1  = NULL;
-       ScfEpin* abcd = NULL;
-
-       ScfEpin* cf0  = NULL;
-       ScfEpin* cf1  = NULL;
-
-       ScfEpin* and0 = NULL;
-       ScfEpin* and1 = NULL;
-       ScfEpin* res  = NULL;
-
-/* (c + 2a)(b + 2d) = bc + 2(ab + cd) + 4ad
+       ScfEpin* ab0 = NULL;
+       ScfEpin* cd0 = NULL;
 
-B0 = bc
-B1 = ab + cd = (a & b) + (c & d)
+       ScfEpin* ab1 = NULL;
+       ScfEpin* cd1 = NULL;
 
-CF = (a & b) & (c & d) = ~NAND(a, b, c, d)
-
-B1 = (a & b) ^ (c & d) = ((a & b) | (c & d)) & ~(a & b & c & d)
-                       = ((a & b) | (c & d)) & NAND(a, b, c, d)
-
-     (a & b) | (c & d) = ~(~(a  &   b)  &  ~(c  &   d))
-                       = ~( (a NAND b)  &   (c NAND d))
-                                          =    (a NAND b) NAND (c NAND d)
-
-B1 = [(a NAND b) NAND (c NAND d)] & NAND(a, b, c, d)
- */
-       int ret = __eda_bit_nand(f, &a0, &b0, &ab0);
+       int ret = __eda_bit_and(f, a, b, &ab0);
        if (ret < 0)
                return ret;
 
-       ret = __eda_bit_nand(f, &c0, &d0, &cd0);
+       ret = __eda_bit_and(f, c, d, &cd0);
        if (ret < 0)
                return ret;
 
-       ret = __eda_bit_nand(f, &ab1, &cd1, &abcd);
+       ret = __eda_bit_add(f, &ab1, &cd1, out, cf);
        if (ret < 0)
                return ret;
 
        EDA_PIN_ADD_PIN_EF(f->ef, ab0, ab1);
        EDA_PIN_ADD_PIN_EF(f->ef, cd0, cd1);
-
-       EDA_INST_ADD_COMPONENT(f->ef, R0, SCF_EDA_Resistor);
-       EDA_INST_ADD_COMPONENT(f->ef, T0, SCF_EDA_NPN);
-       EDA_INST_ADD_COMPONENT(f->ef, T1, SCF_EDA_NPN);
-
-       EDA_PIN_ADD_PIN(R0, 1,             B,  SCF_EDA_Battery_POS);
-       EDA_PIN_ADD_PIN(T0, SCF_EDA_NPN_C, R0, 0);
-       EDA_PIN_ADD_PIN(T1, SCF_EDA_NPN_C, T0, SCF_EDA_NPN_E);
-
-       EDA_PIN_ADD_PIN_EF(f->ef, a0,  T0->pins[SCF_EDA_NPN_B]);
-       EDA_PIN_ADD_PIN_EF(f->ef, b0,  T1->pins[SCF_EDA_NPN_B]);
-       EDA_PIN_ADD_PIN_EF(f->ef, cd0, T1->pins[SCF_EDA_NPN_E]);
-
-       ret = __eda_bit_not(f, &cf0, &cf1);
-       if (ret < 0)
-               return ret;
-       EDA_PIN_ADD_PIN_EF(f->ef, cf0, R0->pins[0]);
-
-       ret = __eda_bit_and(f, &and0, &and1, &res);
-       if (ret < 0)
-               return ret;
-
-       EDA_PIN_ADD_PIN_EF(f->ef, and0, abcd);
-       EDA_PIN_ADD_PIN_EF(f->ef, and1, cf0);
-
-       *a   = a0;
-       *b   = b0;
-       *c   = c0;
-       *d   = d0;
-       *out = res;
-       *cf  = cf1;
        return 0;
 }
 
@@ -790,8 +777,8 @@ static int _eda_inst_mul_handler(scf_native_t* ctx, scf_3ac_code_t* c)
        scf_dag_node_t* in1 = src1->dag_node;
        scf_dag_node_t* out = dst ->dag_node;
 
-       ScfEpin*  adds[256] = {NULL};
-       ScfEpin*  cfs [256] = {NULL};
+       ScfEpin*  adds[SCF_EDA_MAX_BITS] = {NULL};
+       ScfEpin*  cfs [SCF_EDA_MAX_BITS] = {NULL};
 
        int n_adds = 0;
        int n_cfs  = 0;
@@ -823,8 +810,17 @@ static int _eda_inst_mul_handler(scf_native_t* ctx, scf_3ac_code_t* c)
                        EDA_PIN_ADD_INPUT(in0, 0, f->ef, p0j);
                        EDA_PIN_ADD_INPUT(in1, 0, f->ef, p1k);
 
-                       out->pins[0]         = res;
-                       in0->pins[0]->flags |= SCF_EDA_PIN_IN0;
+                       out->pins[0] = res;
+
+                       if (in0->var->arg_flag) {
+                               in0->pins[i]->flags |= SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0;
+                               in0->pins[i]->io_lid = i;
+                       }
+
+                       if (in1->var->arg_flag) {
+                               in1->pins[i]->flags |= SCF_EDA_PIN_IN;
+                               in1->pins[i]->io_lid = i;
+                       }
                        continue;
                }
 
@@ -904,6 +900,16 @@ static int _eda_inst_mul_handler(scf_native_t* ctx, scf_3ac_code_t* c)
 
                n_adds = n_cfs;
                n_cfs  = 0;
+
+               if (in0->var->arg_flag) {
+                       in0->pins[i]->flags |= SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0;
+                       in0->pins[i]->io_lid = i;
+               }
+
+               if (in1->var->arg_flag) {
+                       in1->pins[i]->flags |= SCF_EDA_PIN_IN;
+                       in1->pins[i]->io_lid = i;
+               }
        }
 
        return 0;
@@ -916,24 +922,19 @@ static int _eda_inst_div_handler(scf_native_t* ctx, scf_3ac_code_t* c)
 
 static int _eda_inst_inc_handler(scf_native_t* ctx, scf_3ac_code_t* c)
 {
-       scf_loge("\n");
-       EDA_INST_OP2_CHECK()
+       EDA_INST_SRC_CHECK()
 
-       scf_dag_node_t* in  = src->dag_node;
-       scf_dag_node_t* out = dst->dag_node;
-       ScfEpin*        pc  = NULL;
+       scf_dag_node_t* in = src->dag_node;
+       ScfEpin*        pc = NULL;
 
        int i;
-       int N = eda_variable_size(out->var);
-
-       EDA_INST_IN_CHECK(in,  N);
-       EDA_INST_IN_CHECK(out, N);
+       int N = eda_variable_size(in->var);
 
-       in ->n_pins = N;
-       out->n_pins = N;
+       EDA_INST_IN_CHECK(in, N);
 
-       scf_loge("in: %p, out: %p\n", in, out);
+       in->n_pins = N;
 
+// (x | y) & ~(x & y) == ~y when x = 1
        for (i = 0; i < N; i++) {
 
                ScfEpin* p0  = NULL;
@@ -961,8 +962,12 @@ static int _eda_inst_inc_handler(scf_native_t* ctx, scf_3ac_code_t* c)
                pc         = cf;
                cf->flags |= SCF_EDA_PIN_CF;
 
-               out->pins[i] = res;
-               in ->pins[i]->flags |= SCF_EDA_PIN_IN0;
+               if (in->var->arg_flag) {
+                       in->pins[i]->flags |= SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0;
+                       in->pins[i]->io_lid = i;
+               }
+
+               in->pins[i] = res;
        }
 
        return 0;
@@ -970,7 +975,74 @@ static int _eda_inst_inc_handler(scf_native_t* ctx, scf_3ac_code_t* c)
 
 static int _eda_inst_dec_handler(scf_native_t* ctx, scf_3ac_code_t* c)
 {
-       return -EINVAL;
+       EDA_INST_SRC_CHECK()
+
+       scf_dag_node_t* in = src->dag_node;
+       ScfEpin*        pc = NULL;
+
+       int i;
+       int N = eda_variable_size(in->var);
+
+       EDA_INST_IN_CHECK(in, N);
+
+       in->n_pins = N;
+// y-- == y - 1 == y + (-1) == y + 0xff...ff, every bit add 1
+
+// x + y == (x | y) & ~(x & y) == ~y when x = 1
+       for (i = 0; i < N; i++) {
+
+               ScfEpin* p0  = NULL;
+               ScfEpin* p1  = NULL;
+               ScfEpin* cf  = NULL;
+               ScfEpin* res = NULL;
+
+               if (i > 0) {
+                       ScfEpin* p2  = NULL;
+                       ScfEpin* not = NULL;
+                       ScfEpin* cf0 = NULL;
+                       ScfEpin* cf1 = NULL;
+                       ScfEpin* cf2 = NULL;
+                       ScfEpin* cf3 = NULL;
+
+                       int ret = __eda_bit_not(f, &cf0, &not); // ~cf0 == cf0 + 1
+                       if (ret < 0)
+                               return ret;
+                       EDA_PIN_ADD_PIN_EF(f->ef, cf0, pc);
+
+                       ret = __eda_bit_add(f, &p0, &p1, &res, &cf1);
+                       if (ret < 0)
+                               return ret;
+                       EDA_PIN_ADD_PIN_EF(f->ef, p1, not);
+
+                       ret = __eda_bit_or(f, &cf2, &cf3, &cf);
+                       if (ret < 0)
+                               return ret;
+
+                       EDA_PIN_ADD_PIN_EF(f->ef, cf2, cf0);
+                       EDA_PIN_ADD_PIN_EF(f->ef, cf3, cf1);
+
+               } else {
+                       int ret = __eda_bit_not(f, &p0, &res);
+                       if (ret < 0)
+                               return ret;
+
+                       cf = p0;
+               }
+
+               EDA_PIN_ADD_INPUT(in, i, f->ef, p0);
+
+               pc         = cf;
+               cf->flags |= SCF_EDA_PIN_CF;
+
+               if (in->var->arg_flag) {
+                       in->pins[i]->flags |= SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0;
+                       in->pins[i]->io_lid = i;
+               }
+
+               in->pins[i] = res;
+       }
+
+       return 0;
 }
 
 static int _eda_inst_assign_array_index_handler(scf_native_t* ctx, scf_3ac_code_t* c)
@@ -1142,8 +1214,10 @@ static int _eda_inst_cast_handler(scf_native_t* ctx, scf_3ac_code_t* c)
 
 static int _eda_inst_return_handler(scf_native_t* ctx, scf_3ac_code_t* c)
 {
-       if (!c->srcs || c->srcs->size < 1)
+       if (!c->srcs || c->srcs->size < 1) {
+               scf_loge("\n");
                return -EINVAL;
+       }
 
        scf_eda_context_t*  eda  = ctx->priv;
        scf_function_t*     f    = eda->f;
@@ -1163,8 +1237,10 @@ static int _eda_inst_return_handler(scf_native_t* ctx, scf_3ac_code_t* c)
                        return -EINVAL;
                }
 
-               for (j  = 0; j < out->n_pins; j++)
+               for (j = 0; j < out->n_pins; j++) {
                        out->pins[j]->flags |= SCF_EDA_PIN_OUT;
+                       out->pins[j]->io_lid = j;
+               }
        }
 
        return 0;
@@ -1232,6 +1308,22 @@ static int _eda_inst_save_handler(scf_native_t* ctx, scf_3ac_code_t* c)
 
 static int _eda_inst_assign_handler(scf_native_t* ctx, scf_3ac_code_t* c)
 {
+       EDA_INST_OP2_CHECK()
+
+       scf_dag_node_t* in  = src->dag_node;
+       scf_dag_node_t* out = dst->dag_node;
+
+       int i;
+       int N = eda_variable_size(in->var);
+
+       EDA_INST_IN_CHECK(in, N);
+
+       in ->n_pins = N;
+       out->n_pins = N;
+
+       for (i = 0; i < N; i++) {
+               out->pins[i] = in->pins[i];
+       }
        return 0;
 }
 
@@ -1253,12 +1345,15 @@ static eda_inst_handler_pt eda_inst_handlers[] =
        [SCF_OP_LOGIC_NOT]       =  _eda_inst_logic_not_handler,
        [SCF_OP_BIT_NOT]     =  _eda_inst_bit_not_handler,
 
-       [SCF_OP_INC]         =  _eda_inst_inc_handler,
-       [SCF_OP_DEC]         =  _eda_inst_dec_handler,
+       [SCF_OP_3AC_INC]     =  _eda_inst_inc_handler,
+       [SCF_OP_3AC_DEC]     =  _eda_inst_dec_handler,
 
        [SCF_OP_BIT_AND]     =  _eda_inst_bit_and_handler,
        [SCF_OP_BIT_OR]      =  _eda_inst_bit_or_handler,
 
+       [SCF_OP_SHL]         =  _eda_inst_shl_handler,
+       [SCF_OP_SHR]         =  _eda_inst_shr_handler,
+
        [SCF_OP_ADD]         =  _eda_inst_add_handler,
        [SCF_OP_SUB]         =  _eda_inst_sub_handler,
        [SCF_OP_MUL]         =  _eda_inst_mul_handler,

diff --git a/native/eda/scf_eda_pack.c b/native/eda/scf_eda_pack.c
index 0489d2db347a016fe13a62ab140b2b3e29d8afeb..b17127f62ddb011129c7aeabbb7afbd8ca8e7a35 100644 (file)
--- a/native/eda/scf_eda_pack.c
+++ b/native/eda/scf_eda_pack.c
@@ -16,16 +16,20 @@ static int component_pins[SCF_EDA_Components_NB] =
        SCF_EDA_NAND_NB,
        SCF_EDA_NOR_NB,
        SCF_EDA_NOT_NB,
+
+       SCF_EDA_AND_NB,
+       SCF_EDA_OR_NB,
+       SCF_EDA_XOR_NB,
 };
 
-static int __diode_path_off(ScfEpin* p0, ScfEpin* p1)
+static int __diode_path_off(ScfEpin* p0, ScfEpin* p1, int flags)
 {
        if (SCF_EDA_Diode_NEG == p0->id)
                return 1;
        return 0;
 }
 
-static int __npn_path_off(ScfEpin* p0, ScfEpin* p1)
+static int __npn_path_off(ScfEpin* p0, ScfEpin* p1, int flags)
 {
        if (SCF_EDA_NPN_E == p0->id)
                return 1;
@@ -35,28 +39,31 @@ static int __npn_path_off(ScfEpin* p0, ScfEpin* p1)
        return 1;
 }
 
-static int __npn_shared(ScfEpin* p)
+static int __npn_shared(ScfEpin* p, int flags)
 {
        if (SCF_EDA_NPN_E == p->id)
                return 1;
        return 0;
 }
 
-static int __pnp_path_off(ScfEpin* p0, ScfEpin* p1)
+static int __pnp_path_off(ScfEpin* p0, ScfEpin* p1, int flags)
 {
-       if (SCF_EDA_PNP_E == p0->id)
+       if (SCF_EDA_PNP_E != p0->id)
+               return 1;
+
+       if (!p1 || SCF_EDA_PNP_E != p1->id)
                return 0;
        return 1;
 }
 
-static int __pnp_shared(ScfEpin* p)
+static int __pnp_shared(ScfEpin* p, int flags)
 {
        if (SCF_EDA_PNP_E == p->id)
                return 1;
        return 0;
 }
 
-static int __nand_path_off(ScfEpin* p0, ScfEpin* p1)
+static int __nand_path_off(ScfEpin* p0, ScfEpin* p1, int flags)
 {
        if (SCF_EDA_NAND_NEG == p0->id)
                return 1;
@@ -64,41 +71,45 @@ static int __nand_path_off(ScfEpin* p0, ScfEpin* p1)
        if (SCF_EDA_NAND_POS == p0->id) {
                if (p1 && (SCF_EDA_NAND_IN0 == p1->id || SCF_EDA_NAND_IN1 == p1->id))
                        return 1;
-
-       } else if (p1 && SCF_EDA_NAND_NEG != p1->id)
-               return 1;
+       } else {
+               if (p1) {
+                       if (!flags && (SCF_EDA_NAND_IN0 == p0->id || SCF_EDA_NAND_IN1 == p0->id)
+                                       &&  SCF_EDA_NAND_OUT == p1->id)
+                               return 0;
+
+                       if (SCF_EDA_NAND_NEG != p1->id)
+                               return 1;
+               }
+       }
        return 0;
 }
 
-static int __nand_shared(ScfEpin* p)
+static int __nand_shared(ScfEpin* p, int flags)
 {
        if (SCF_EDA_NAND_NEG == p->id || SCF_EDA_NAND_POS == p->id)
                return 1;
-       return 0;
-}
-
-static int __nor_path_off(ScfEpin* p0, ScfEpin* p1)
-{
-       if (SCF_EDA_NOR_NEG == p0->id)
-               return 1;
-
-       if (SCF_EDA_NOR_POS == p0->id) {
-               if (p1 && (SCF_EDA_NOR_IN0 == p1->id || SCF_EDA_NOR_IN1 == p1->id))
-                       return 1;
 
-       } else if (p1 && SCF_EDA_NOR_NEG != p1->id)
+       if (!flags && SCF_EDA_NAND_OUT != p->id)
                return 1;
        return 0;
 }
 
-static int __nor_shared(ScfEpin* p)
-{
-       if (SCF_EDA_NOR_NEG == p->id || SCF_EDA_NOR_POS == p->id)
-               return 1;
-       return 0;
+#define SCF_EDA_GATE(name, off, shared) \
+static int __##name##_path_off(ScfEpin* p0, ScfEpin* p1, int flags) \
+{ \
+       return off(p0, p1, flags); \
+} \
+static int __##name##_shared(ScfEpin* p, int flags) \
+{ \
+       return shared(p, flags); \
 }
+SCF_EDA_GATE(nor, __nand_path_off, __nand_shared)
+SCF_EDA_GATE(and, __nand_path_off, __nand_shared)
+SCF_EDA_GATE(or,  __nand_path_off, __nand_shared)
+SCF_EDA_GATE(xor, __nand_path_off, __nand_shared)
+
 
-static int __not_path_off(ScfEpin* p0, ScfEpin* p1)
+static int __not_path_off(ScfEpin* p0, ScfEpin* p1, int flags)
 {
        if (SCF_EDA_NOT_NEG == p0->id)
                return 1;
@@ -106,16 +117,25 @@ static int __not_path_off(ScfEpin* p0, ScfEpin* p1)
        if (SCF_EDA_NOT_POS == p0->id) {
                if (p1 && SCF_EDA_NOT_IN == p1->id)
                        return 1;
+       } else {
+               if (p1) {
+                       if (!flags && SCF_EDA_NOT_IN == p0->id && SCF_EDA_NOT_OUT == p1->id)
+                               return 0;
 
-       } else if (p1 && SCF_EDA_NOT_NEG != p1->id)
-               return 1;
+                       if (SCF_EDA_NOT_NEG != p1->id)
+                               return 1;
+               }
+       }
        return 0;
 }
 
-static int __not_shared(ScfEpin* p)
+static int __not_shared(ScfEpin* p, int flags)
 {
        if (SCF_EDA_NOT_NEG == p->id || SCF_EDA_NOT_POS == p->id)
                return 1;
+
+       if (!flags && SCF_EDA_NOT_OUT != p->id)
+               return 1;
        return 0;
 }
 
@@ -149,6 +169,24 @@ static ScfEops __nor_ops =
        __nor_shared,
 };
 
+static ScfEops __and_ops =
+{
+       __and_path_off,
+       __and_shared,
+};
+
+static ScfEops __or_ops =
+{
+       __or_path_off,
+       __or_shared,
+};
+
+static ScfEops __xor_ops =
+{
+       __xor_path_off,
+       __xor_shared,
+};
+
 static ScfEops __not_ops =
 {
        __not_path_off,
@@ -166,11 +204,15 @@ static ScfEdata  component_datas[] =
 
        {SCF_EDA_Diode,      0,                   0, 0, 0,    0,   0,   0, 0, &__diode_ops, NULL, NULL},
        {SCF_EDA_NPN,        0,                   0, 0, 0,    0,   0,   0, 0, &__npn_ops,   NULL, "./cpk/9013.txt"},
-       {SCF_EDA_PNP,        0,                   0, 0, 0,    0,   0,   0, 0, &__pnp_ops,   NULL, NULL},
+       {SCF_EDA_PNP,        0,                   0, 0, 0,    0,   0,   0, 0, &__pnp_ops,   NULL, "./cpk/9012.txt"},
 
        {SCF_EDA_NAND,       0,                   0, 0, 0,    0,   0,   0, 0, &__nand_ops,  "./cpk/nand.cpk", NULL},
-       {SCF_EDA_NOR,        0,                   0, 0, 0,    0,   0,   0, 0, &__nor_ops,   "./cpk/nor.cpk", NULL},
-       {SCF_EDA_NOT,        0,                   0, 0, 0,    0,   0,   0, 0, &__not_ops,   "./cpk/not.cpk", NULL},
+       {SCF_EDA_NOR,        0,                   0, 0, 0,    0,   0,   0, 0, &__nor_ops,   "./cpk/nor.cpk",  NULL},
+       {SCF_EDA_NOT,        0,                   0, 0, 0,    0,   0,   0, 0, &__not_ops,   "./cpk/not.cpk",  NULL},
+
+       {SCF_EDA_AND,        0,                   0, 0, 0,    0,   0,   0, 0, &__and_ops,   "./cpk/and.cpk",  NULL},
+       {SCF_EDA_OR,         0,                   0, 0, 0,    0,   0,   0, 0, &__or_ops,    "./cpk/or.cpk",   NULL},
+       {SCF_EDA_XOR,        0,                   0, 0, 0,    0,   0,   0, 0, &__xor_ops,   "./cpk/xor.cpk",  NULL},
 };
 
 static ScfEdata  pin_datas[] =
@@ -823,6 +865,9 @@ int scf_pins_same_line(ScfEfunction* f)
                                                p ->lid    = el->id;
                                                p ->c_lid  = el->id;
                                                el->flags |= p->flags;
+
+                                               if (p->flags & (SCF_EDA_PIN_IN | SCF_EDA_PIN_OUT))
+                                                       el->io_lid = p->io_lid;
                                                goto next;
                                        }
                                }
@@ -844,6 +889,9 @@ int scf_pins_same_line(ScfEfunction* f)
                        p ->lid    = el->id;
                        p ->c_lid  = el->id;
                        el->flags |= p->flags;
+
+                       if (p->flags & (SCF_EDA_PIN_IN | SCF_EDA_PIN_OUT))
+                               el->io_lid = p->io_lid;
 next:
                        for (n = 0; n + 1 < p->n_tos; n += 2) {
 
@@ -870,6 +918,9 @@ next:
                                        p2->lid    = el->id;
                                        p2->c_lid  = el->id;
                                        el->flags |= p2->flags;
+
+                                       if (p2->flags & (SCF_EDA_PIN_IN | SCF_EDA_PIN_OUT))
+                                               el->io_lid = p2->io_lid;
                                }
 
                                qsort(el->pins, el->n_pins / 2, sizeof(uint64_t) * 2, epin_cmp);

diff --git a/native/eda/scf_eda_pack.h b/native/eda/scf_eda_pack.h
index f3813b8efcc20dec2c002c95aa9fa3f839c138ac..eaf35f4c725be70330d05adf391405cca5fe915d 100644 (file)
--- a/native/eda/scf_eda_pack.h
+++ b/native/eda/scf_eda_pack.h
@@ -19,6 +19,10 @@ enum {
        SCF_EDA_NOR,
        SCF_EDA_NOT,
 
+       SCF_EDA_AND,
+       SCF_EDA_OR,
+       SCF_EDA_XOR,
+
        SCF_EDA_Components_NB,
 };
 
@@ -90,16 +94,49 @@ enum {
 };
 
 enum {
-       SCF_EDA_NOR_NEG,
-       SCF_EDA_NOR_POS,
+       SCF_EDA_NOR_NEG = SCF_EDA_NAND_NEG,
+       SCF_EDA_NOR_POS = SCF_EDA_NAND_POS,
 
-       SCF_EDA_NOR_IN0,
-       SCF_EDA_NOR_IN1,
-       SCF_EDA_NOR_OUT,
+       SCF_EDA_NOR_IN0 = SCF_EDA_NAND_IN0,
+       SCF_EDA_NOR_IN1 = SCF_EDA_NAND_IN1,
+       SCF_EDA_NOR_OUT = SCF_EDA_NAND_OUT,
 
        SCF_EDA_NOR_NB,
 };
 
+enum {
+       SCF_EDA_AND_NEG = SCF_EDA_NAND_NEG,
+       SCF_EDA_AND_POS = SCF_EDA_NAND_POS,
+
+       SCF_EDA_AND_IN0 = SCF_EDA_NAND_IN0,
+       SCF_EDA_AND_IN1 = SCF_EDA_NAND_IN1,
+       SCF_EDA_AND_OUT = SCF_EDA_NAND_OUT,
+
+       SCF_EDA_AND_NB,
+};
+
+enum {
+       SCF_EDA_OR_NEG = SCF_EDA_NAND_NEG,
+       SCF_EDA_OR_POS = SCF_EDA_NAND_POS,
+
+       SCF_EDA_OR_IN0 = SCF_EDA_NAND_IN0,
+       SCF_EDA_OR_IN1 = SCF_EDA_NAND_IN1,
+       SCF_EDA_OR_OUT = SCF_EDA_NAND_OUT,
+
+       SCF_EDA_OR_NB,
+};
+
+enum {
+       SCF_EDA_XOR_NEG = SCF_EDA_NAND_NEG,
+       SCF_EDA_XOR_POS = SCF_EDA_NAND_POS,
+
+       SCF_EDA_XOR_IN0 = SCF_EDA_NAND_IN0,
+       SCF_EDA_XOR_IN1 = SCF_EDA_NAND_IN1,
+       SCF_EDA_XOR_OUT = SCF_EDA_NAND_OUT,
+
+       SCF_EDA_XOR_NB,
+};
+
 enum {
        SCF_EDA_NOT_NEG,
        SCF_EDA_NOT_POS,
@@ -162,8 +199,9 @@ typedef struct scf_eboard_s      ScfEboard;
 
 struct scf_eops_s
 {
-       int (*off   )(ScfEpin* p0, ScfEpin* p1);
-       int (*shared)(ScfEpin* p);
+       int (*off   )(ScfEpin* p0, ScfEpin* p1, int flags);
+
+       int (*shared)(ScfEpin* p,  int flags);
 };
 
 struct scf_epin_s
@@ -175,6 +213,8 @@ struct scf_epin_s
        SCF_PACK_DEF_VARS(uint64_t, tos);
        SCF_PACK_DEF_VAR(uint64_t, c_lid);
 
+       SCF_PACK_DEF_VAR(int64_t, io_lid);
+
        SCF_PACK_DEF_VAR(int64_t, ic_lid);
        SCF_PACK_DEF_OBJ(ScfEcomponent, IC);
 
@@ -197,7 +237,6 @@ struct scf_epin_s
        SCF_PACK_DEF_VAR(int, y);
 
        SCF_PACK_DEF_VAR(int, n_diodes);
-       SCF_PACK_DEF_VAR(int, l_pos);
 
        SCF_PACK_DEF_VAR(uint8_t, vflag);
        SCF_PACK_DEF_VAR(uint8_t, pflag);
@@ -213,6 +252,7 @@ SCF_PACK_INFO_VAR(ScfEpin, flags),
 SCF_PACK_INFO_VARS(ScfEpin, tos, uint64_t),
 SCF_PACK_INFO_VAR(ScfEpin, c_lid),
 
+SCF_PACK_INFO_VAR(ScfEpin, io_lid),
 SCF_PACK_INFO_VAR(ScfEpin, ic_lid),
 
 SCF_PACK_INFO_VAR(ScfEpin, v),
@@ -231,7 +271,6 @@ SCF_PACK_INFO_VAR(ScfEpin, path),
 SCF_PACK_INFO_VAR(ScfEpin, x),
 SCF_PACK_INFO_VAR(ScfEpin, y),
 SCF_PACK_INFO_VAR(ScfEpin, n_diodes),
-SCF_PACK_INFO_VAR(ScfEpin, l_pos),
 
 SCF_PACK_INFO_VAR(ScfEpin, vflag),
 SCF_PACK_INFO_VAR(ScfEpin, pflag),
@@ -255,6 +294,9 @@ typedef struct {
        SCF_PACK_DEF_VAR(uint64_t, c_pins);
        SCF_PACK_DEF_VAR(uint64_t, flags);
        SCF_PACK_DEF_VAR(int64_t, color);
+       SCF_PACK_DEF_VAR(int64_t, io_lid);
+
+       SCF_PACK_DEF_OBJ(ScfEfunction, pf);
 
        SCF_PACK_DEF_OBJS(ScfEconn, conns);
        SCF_PACK_DEF_OBJS(ScfLine, lines);
@@ -274,6 +316,7 @@ SCF_PACK_INFO_VARS(ScfEline, pins, uint64_t),
 SCF_PACK_INFO_VAR(ScfEline, c_pins),
 SCF_PACK_INFO_VAR(ScfEline, flags),
 SCF_PACK_INFO_VAR(ScfEline, color),
+SCF_PACK_INFO_VAR(ScfEline, io_lid),
 
 SCF_PACK_INFO_OBJS(ScfEline, conns, ScfEconn),
 SCF_PACK_INFO_OBJS(ScfEline, lines, ScfLine),
@@ -352,6 +395,9 @@ struct scf_efunction_s
        SCF_PACK_DEF_VARS(uint8_t, name);
        SCF_PACK_DEF_OBJS(ScfEcomponent, components);
        SCF_PACK_DEF_OBJS(ScfEline,      elines);
+
+       SCF_PACK_DEF_OBJ(ScfEcomponent, IC);
+
        SCF_PACK_DEF_VAR(int, x);
        SCF_PACK_DEF_VAR(int, y);
        SCF_PACK_DEF_VAR(int, w);

diff --git a/pack/scf_pack.c b/pack/scf_pack.c
index e49ead736e11a9dcdb6bdcb6aec3fc79509abc5a..1e93428f9a32948ddacc08514d24b67c80065485 100644 (file)
--- a/pack/scf_pack.c
+++ b/pack/scf_pack.c
@@ -19,7 +19,6 @@ long __scf_pack_one_index(uint8_t* pack, uint64_t u, long shift)
                        max = i;
                else
                        max -= i;
-               scf_logd("max: %d, i: %d, j: %d, k: %d, shift: %d\n", max, i, j, k, shift);
 
                pack[j] |= max << k;
 
@@ -48,15 +47,13 @@ long __scf_pack_one_index(uint8_t* pack, uint64_t u, long shift)
                        return -EINVAL;
                }
 
-               scf_logd("max: %d, i: %d, j: %d, k: %d, shift: %d\n\n", max, i, j, k, shift);
+               scf_logd("max: %ld, i: %ld, j: %ld, k: %ld, shift: %ld\n\n", max, i, j, k, shift);
 
                max = i;
        }
 
-       if (8 - k < shift && 0 != max) {
+       if (8 - k < shift && 0 != max)
                pack[++j] = 0;
-               scf_logd("max: %d, i: %d, j: %d, k: %d, shift: %d\n\n", max, i, j, k, shift);
-       }
 
        return j + 1;
 }
@@ -201,7 +198,9 @@ long __scf_unpack2(void* p, long shift, const uint8_t* buf, long len)
                                return -EINVAL;
                        }
 
-                       scf_logd("max: %d, i: %d, j: %d, k: %d, shift: %d\n\n", max, i, j, k, shift);
+                       scf_logd("max: %ld, i: %ld, j: %ld, k: %ld, shift: %ld\n\n", max, i, j, k, shift);
+                       if (0 == max)
+                               break;
                }
 
                j++;
@@ -354,7 +353,6 @@ long scf_pack(void* p, scf_pack_info_t* infos, long n_infos, uint8_t** pbuf, lon
        if (!*pbuf)
                *plen = 0;
 
-//     prlongf("\n");
        scf_logd("p: %p\n", p);
 
        long i;

diff --git a/parse/scf_parse.c b/parse/scf_parse.c
index ffc248cb898ec4382f641972c56c73fb4ae00057..357527dc1798c4087e38351f7f9bbd7cd76ec367 100644 (file)
--- a/parse/scf_parse.c
+++ b/parse/scf_parse.c
@@ -24,9 +24,14 @@ scf_base_type_t      base_types[] =
 
        {SCF_VAR_VOID,      "void",       1},
        {SCF_VAR_BIT,       "bit",        1},
-       {SCF_VAR_BIT2,      "bit2_t",     1},
-       {SCF_VAR_BIT3,      "bit3_t",     1},
-       {SCF_VAR_BIT4,      "bit4_t",     1},
+       {SCF_VAR_U2,        "bit2_t",     1},
+       {SCF_VAR_U3,        "bit3_t",     1},
+       {SCF_VAR_U4,        "bit4_t",     1},
+
+       {SCF_VAR_I1,        "int1_t",     1},
+       {SCF_VAR_I2,        "int2_t",     1},
+       {SCF_VAR_I3,        "int3_t",     1},
+       {SCF_VAR_I4,        "int4_t",     1},
 
        {SCF_VAR_INT,           "int",            4},
        {SCF_VAR_FLOAT,     "float",      4},