mirror of
https://port.numenaute.org/aleajactaest/clientbot.git
synced 2024-11-22 23:26:23 +00:00
319 lines
9.2 KiB
Python
319 lines
9.2 KiB
Python
#!/usr/bin/python3
|
|
# -*- coding: utf-8 -*-
|
|
#
|
|
# module CArg
|
|
#
|
|
# Copyright (C) 2019 AleaJactaEst
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
from ctypes import *
|
|
from tools import Enum
|
|
|
|
# #####################################################
|
|
# persistent_data.h:140 # struct CArg
|
|
# #####################################################
|
|
class CArgV1(Structure):
|
|
_fields_ = [("i32_1", c_uint),
|
|
("i32_2", c_uint)]
|
|
|
|
|
|
class CArgV2(Structure):
|
|
_fields_ = [("ex32_1", c_uint),
|
|
("ex32_2", c_uint)]
|
|
|
|
|
|
class CArgV3(Union):
|
|
_fields_ = [("ex32", CArgV2),
|
|
("ExData32", c_uint),
|
|
("ExData64", c_ulong)]
|
|
|
|
|
|
class CArgV4(Structure):
|
|
_fields_ = [("ExType", c_uint),
|
|
("ex", CArgV3)]
|
|
|
|
|
|
class CArgV5(Union):
|
|
_fields_ = [("i", CArgV1),
|
|
("ii32", c_int),
|
|
("ii64", c_long),
|
|
("i32", c_uint),
|
|
("i64", c_ulong),
|
|
("f32", c_float),
|
|
("f64", c_double),
|
|
("ex", CArgV4)]
|
|
|
|
class CArg:
|
|
# union
|
|
# {
|
|
# struct
|
|
# {
|
|
# uint32 i32_1;
|
|
# uint32 i32_2;
|
|
# } i;
|
|
#
|
|
# sint32 i32;
|
|
# sint64 i64;
|
|
# float f32;
|
|
# double f64;
|
|
#
|
|
# struct
|
|
# {
|
|
# uint32 ExType;
|
|
# union
|
|
# {
|
|
# struct
|
|
# {
|
|
# uint32 ex32_1;
|
|
# uint32 ex32_2;
|
|
# };
|
|
#
|
|
# uint32 ExData32;
|
|
# uint64 ExData64;
|
|
# } ex;
|
|
# } ex;
|
|
# } _Value;
|
|
|
|
def __init__(self):
|
|
self._value = CArgV5()
|
|
self._value.ii64 = 0
|
|
self._value.i64 = 0
|
|
self._type = 0
|
|
self._string = 0
|
|
self._type64 = False
|
|
|
|
def read_Type(self):
|
|
return self._type
|
|
|
|
def write_Type(self, value):
|
|
self._type = value
|
|
|
|
def write_Type64(self, value):
|
|
self._type64 = value
|
|
|
|
def read_String(self):
|
|
return self._string
|
|
|
|
def write_String(self, value):
|
|
self._string = value
|
|
|
|
def read_i32_1(self):
|
|
return self._value.i.i32_1
|
|
|
|
def write_i32_1(self, value):
|
|
self._value.i.i32_1 = value
|
|
|
|
def read_i32_2(self):
|
|
return self._value.i.i32_2
|
|
|
|
def write_i32_2(self, value):
|
|
self._value.i.i32_2 = value
|
|
|
|
def read_i32(self):
|
|
return self._value.i32
|
|
|
|
def write_i32(self, value):
|
|
self._value.i32 = value
|
|
|
|
def read_i64(self):
|
|
return self._value.i64
|
|
|
|
def write_i64(self, value):
|
|
self._value.i64 = value
|
|
|
|
def read_f32(self):
|
|
return self._value.f32
|
|
|
|
def write_f32(self, value):
|
|
self._value.f32 = value
|
|
|
|
def read_f64(self):
|
|
return self._value.f64
|
|
|
|
def write_f64(self, value):
|
|
self._value.f64 = value
|
|
|
|
def read_ExType(self):
|
|
return self._value.ex.ExType
|
|
|
|
def write_ExType(self, value):
|
|
self._value.ex.ExType = value
|
|
|
|
def read_ex32_1(self):
|
|
return self._value.ex.ex.ex32.ex32_1
|
|
|
|
def write_ex32_1(self, value):
|
|
self._value.ex.ex.ex32.ex32_1 = value
|
|
|
|
def read_ex32_2(self):
|
|
return self._value.ex.ex.ex32.ex32_2
|
|
|
|
def write_ex32_2(self, value):
|
|
self._value.ex.ex.ex32.ex32_2 = value
|
|
|
|
def read_ExData32(self):
|
|
return self._value.ex.ex.ExData32
|
|
|
|
def write_ExData32(self, value):
|
|
self._value.ex.ex.ExData32 = value
|
|
|
|
def read_ExData64(self):
|
|
return self._value.ex.ex.ExData64
|
|
|
|
def write_ExData64(self, value):
|
|
self._value.ex.ex.ExData64 = value
|
|
|
|
def isExtended(self):
|
|
if self._type == Enum.TType.EXTEND_TYPE:
|
|
return True
|
|
elif self._type == Enum.TType.STRUCT_BEGIN:
|
|
self.log.error("Can't extract a value from a structure delimiter")
|
|
sys.exit(2)
|
|
elif self._type == Enum.TType.STRUCT_END:
|
|
self.log.error("Can't extract a value from a structure delimiter")
|
|
sys.exit(2)
|
|
return False
|
|
|
|
def isFlag(self):
|
|
if self._type == Enum.TType.FLAG:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
def asUint(self):
|
|
if self._type == Enum.TType.STRUCT_BEGIN or self._type == Enum.TType.STRUCT_END:
|
|
self.log.error("Can't extract a value from a structure delimiter")
|
|
sys.exit(2)
|
|
elif self._type == Enum.TType.SINT32:
|
|
return self.read_i32()
|
|
elif self._type == Enum.TType.UINT32:
|
|
return self.read_i32()
|
|
elif self._type == Enum.TType.SINT64:
|
|
return self.read_i64()
|
|
elif self._type == Enum.TType.UINT64:
|
|
return self.read_i64()
|
|
elif self._type == Enum.TType.FLOAT32:
|
|
return self.read_i32()
|
|
elif self._type == Enum.TType.FLOAT64:
|
|
return self.read_i64()
|
|
elif self._type == Enum.TType.STRING:
|
|
return int(self._string)
|
|
elif self._type == Enum.TType.FLAG:
|
|
return "1"
|
|
elif self._type == Enum.TType.EXTEND_TYPE:
|
|
if self.read_ExType() == TExtendType.ET_SHEET_ID:
|
|
return self.read_ExData32()
|
|
elif self.read_ExType() == TExtendType.ET_ENTITY_ID:
|
|
return self.read_ExData64()
|
|
log = logging.getLogger('myLogger')
|
|
log.error("This should never happen!")
|
|
sys.exit(2)
|
|
|
|
def __str__(self):
|
|
log = logging.getLogger('myLogger')
|
|
log.debug(self._type)
|
|
if self._type == Enum.TType.STRUCT_BEGIN or self._type == Enum.TType.STRUCT_END:
|
|
return ''
|
|
elif self._type64:
|
|
# To be confirm for extend
|
|
return str(self.read_ExData64())
|
|
elif self._type == Enum.TType.SINT32:
|
|
return str(self.read_i32())
|
|
elif self._type == Enum.TType.UINT32:
|
|
return str(self.read_i32())
|
|
elif self._type == Enum.TType.SINT64:
|
|
return str(self.read_i64())
|
|
elif self._type == Enum.TType.UINT64:
|
|
return str(self.read_i64())
|
|
elif self._type == Enum.TType.FLOAT32:
|
|
return str(self.read_i32())
|
|
elif self._type == Enum.TType.FLOAT64:
|
|
return str(self.read_i64())
|
|
elif self._type == Enum.TType.STRING:
|
|
return self._string
|
|
elif self._type == Enum.TType.FLAG:
|
|
return "1"
|
|
return '?'
|
|
|
|
def asSint(self):
|
|
self.log.error("TODO")
|
|
sys.exit(2)
|
|
|
|
def asFloat(self):
|
|
self.log.error("TODO")
|
|
sys.exit(2)
|
|
|
|
def asDouble(self):
|
|
self.log.error("TODO")
|
|
sys.exit(2)
|
|
|
|
def asString(self):
|
|
if self._type == Enum.TType.STRUCT_BEGIN or self._type == Enum.TType.STRUCT_END:
|
|
self.log.error("Can't extract a value from a structure delimiter")
|
|
sys.exit(2)
|
|
elif self._type == Enum.TType.SINT32:
|
|
return str(self.read_ii32())
|
|
elif self._type == Enum.TType.UINT32:
|
|
return str(self.read_i32())
|
|
elif self._type == Enum.TType.SINT64:
|
|
return str(self.read_ii64())
|
|
elif self._type == Enum.TType.UINT64:
|
|
return str(self.read_i64())
|
|
elif self._type == Enum.TType.FLOAT32:
|
|
return str(self.read_f32())
|
|
elif self._type == Enum.TType.FLOAT64:
|
|
return str(self.read_f64())
|
|
elif self._type == Enum.TType.STRING:
|
|
return self._string
|
|
elif self._type == Enum.TType.FLAG:
|
|
return "1"
|
|
elif self._type == Enum.TType.EXTEND_TYPE:
|
|
self.log.error("TODO")
|
|
sys.exit(2)
|
|
# switch(_Value.ExType)
|
|
# {
|
|
# case ET_SHEET_ID:
|
|
# {
|
|
# NLMISC::CSheetId sheetId(_Value.ExData32);
|
|
# return sheetId.toString(true);
|
|
# }
|
|
# case ET_ENTITY_ID:
|
|
# {
|
|
# NLMISC::CEntityId entityId(_Value.ExData64);
|
|
# return entityId.toString();
|
|
# }
|
|
# default:
|
|
# break;
|
|
# }
|
|
self.log.error("This should never happen!")
|
|
sys.exit(2)
|
|
|
|
def asUCString(self):
|
|
self.log.error("TODO")
|
|
sys.exit(2)
|
|
|
|
def asEntityId(self):
|
|
self.log.error("TODO")
|
|
sys.exit(2)
|
|
|
|
def asSheetId(self):
|
|
self.log.error("TODO")
|
|
sys.exit(2)
|
|
|
|
def typeName(self):
|
|
self.log.error("TODO")
|
|
sys.exit(2)
|
|
|
|
# #####################################################
|