public virtual bool Write2buffer_Instructions(ref List <byte> bf)
        {
            try
            {
                StructFile sf_operator;
                OPERAND    _operand;
                for (int j = 0; j < instructionlist.Count; j++)
                {
                    sf_operator = new StructFile(typeof(OPERATOR));
                    OPERATOR _operator = instructionlist[j].Operator;
                    //_operator.ReturnType = Common.ntohi(_operator.ReturnType);
                    //_operator.OpCode = Common.ntohi(_operator.OpCode);
                    _operator.Res2 = 2;
                    _operator.Res3 = 3;
                    sf_operator.WriteStructure(ref bf, (object)_operator);

                    for (int k = 0; k < instructionlist[j].OperandList.Count; k++)
                    {
                        sf_operator = new StructFile(typeof(OPERAND));
                        _operand    = instructionlist[j].OperandList[k];
                        //_operand.Index = Common.ntohl(_operand.Index);
                        instructionlist[j].OperandList[k] = _operand;
                        sf_operator.WriteStructure(ref bf, (object)instructionlist[j].OperandList[k]);
                    }
                }
                return(true);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                return(false);
            }
        }
Beispiel #2
0
 public override bool Write2File_OPERATION(BinaryWriter bw)
 {
     try
     {
         OPERATION  _operation   = new OPERATION();
         StructFile sf_operation = new StructFile(typeof(OPERATION));
         _operation.Size1         = QSize();
         _operation.Size2         = ThenSize();
         _operation.Size3         = ElseSize();
         _operation.operationType = (int)OPERATION_TYPE.IF_ELSE_OPERATION;
         _operation.Size1         = Common.ntohi(_operation.Size1);
         _operation.Size2         = Common.ntohi(_operation.Size2);
         _operation.Size3         = Common.ntohi(_operation.Size3);
         sf_operation.WriteStructure(bw, (object)_operation);
         return(true);
     }
     catch (Exception ex)
     {
         MessageBox.Show(ex.Message);
         return(false);
     }
 }
 public virtual bool Write2Buffer_OPERATION(ref List <byte> bf)
 {
     try
     {
         OPERATION  _operation   = new OPERATION();
         StructFile sf_operation = new StructFile(typeof(OPERATION));
         _operation.Size1         = Size();
         _operation.Size2         = 0;
         _operation.Size3         = 0;
         _operation.operationType = (int)OPERATION_TYPE.SIMPLE_OPERATION;
         //_operation.Size1 = Common.ntohi(_operation.Size1);
         //_operation.Size2 = Common.ntohi(_operation.Size2);
         //_operation.Size3 = Common.ntohi(_operation.Size3);
         sf_operation.WriteStructure(ref bf, (object)_operation);
         return(true);
     }
     catch (Exception ex)
     {
         MessageBox.Show(ex.Message);
         return(false);
     }
 }
Beispiel #4
0
        public byte[] SaveCompiledExpressions()
        {
            List <byte> buffer = new List <byte>();
            //VALUE _value = new VALUE();
            //string _valuestr = "";
            int size = 0;

            DrawExpressionCollectionCode drawexpressioncollectioncode = new DrawExpressionCollectionCode();

            size = Marshal.SizeOf(drawexpressioncollectioncode);
            drawexpressioncollectioncode.BufferSize            = size;
            drawexpressioncollectioncode.IsValid               = 1;
            drawexpressioncollectioncode.NoOfDynamicProperties = objDisplayObjectDynamicPropertys.Count;
            //drawexpressioncollectioncode.NoOfExpressions = 0;
            // add above structure to buffer
            StructFile sfDrawExpressionCollectionCode = new StructFile(typeof(DrawExpressionCollectionCode));

            sfDrawExpressionCollectionCode.WriteStructure(ref buffer, (object)drawexpressioncollectioncode);
            //

            foreach (DisplayObjectDynamicProperty exs in objDisplayObjectDynamicPropertys.list)
            {
                ExpressionCode expressioncode = new ExpressionCode();

                size = Marshal.SizeOf(expressioncode);
                expressioncode.Property       = (int)exs.ObjectType;
                expressioncode.NoOfConditions = exs.NoOfConditions;
                expressioncode.ReturnType     = (int)exs.Type;
                if (exs.IsColor)
                {
                    expressioncode.IsColor = 1;
                }
                else
                {
                    expressioncode.IsColor = 0;
                }
                expressioncode.ExecutionType = 1;//  0 initialization  1 Cyclic
                expressioncode.IsValid       = 0;

                StructFile sfEcpressionCode = new StructFile(typeof(ExpressionCode));

                expressioncode.IsValid = 1;

                FillPropertyList(ref expressioncode, exs.ObjectType);
                sfEcpressionCode.WriteStructure(ref buffer, (object)expressioncode);

                foreach (DisplayObjectDynamicPropertyCondition cs in exs.ConditionList)
                {
                    ConditionCode conditioncode = new ConditionCode();
                    //conditioncode.StrValue = new STRINGOBJ();
                    conditioncode.Size = cs.SimpleOperation.Size1();
                    if (exs.IsString)
                    {
                        //unsafe
                        {
                            conditioncode.StrValue.Len   = cs.m_StrValue.Len;
                            conditioncode.StrValue.Val00 = cs.m_StrValue.Val00;
                            conditioncode.StrValue.Val01 = cs.m_StrValue.Val01;
                            conditioncode.StrValue.Val02 = cs.m_StrValue.Val02;
                            conditioncode.StrValue.Val03 = cs.m_StrValue.Val03;
                            conditioncode.StrValue.Val04 = cs.m_StrValue.Val04;
                            conditioncode.StrValue.Val05 = cs.m_StrValue.Val05;
                            conditioncode.StrValue.Val06 = cs.m_StrValue.Val06;
                            conditioncode.StrValue.Val07 = cs.m_StrValue.Val07;
                            conditioncode.StrValue.Val08 = cs.m_StrValue.Val08;
                            conditioncode.StrValue.Val09 = cs.m_StrValue.Val09;
                            conditioncode.StrValue.Val10 = cs.m_StrValue.Val10;
                            conditioncode.StrValue.Val11 = cs.m_StrValue.Val11;
                            conditioncode.StrValue.Val12 = cs.m_StrValue.Val12;
                            conditioncode.StrValue.Val13 = cs.m_StrValue.Val13;
                            conditioncode.StrValue.Val14 = cs.m_StrValue.Val14;
                            conditioncode.StrValue.Val15 = cs.m_StrValue.Val15;
                            //for (int k = 0; k < cs.m_StrValue.Len; k++)
                            //{
                            //    conditioncode.Val[k] = cs.m_StrValue.Val[k];
                            //}
                        }
                    }
                    else
                    {
                        conditioncode.Value.ULINT = cs.m_Value.ULINT;
                    }
                    StructFile sfConditionCode = new StructFile(typeof(ConditionCode));
                    sfConditionCode.WriteStructure(ref buffer, conditioncode);
                    cs.SimpleOperation.Write2Buffer(ref buffer);
                }
            }

            return(buffer.ToArray());
        }