Undefinded Syntax Error?

Question

Very new to this, but so far have had a little help in making this. It keeps giving syntax error on line 131.. and many other errors too. Im not really sure on what it is and the person who helped me create this is gone leaving me by my noob self to try and fix this.There is more to the script in the middle after -------- which decompiles the direct files but i cant post them. But i only need to figure out whats wrong with this "syntax error" so, Whats worng with this script?

    #o-----------------------------------------------------------------------------o
    #(-----------------------------------------------------------------------------)
    #|Compatible w/ Python 3.2 |
    #########################
    # Configuration section #
    #########################
    toptablefolder = 'C:/Games/TOP/kop/scripts/table/'
    toptableversion = 6 
    toptableencoding = 'gbk'
    ####end of config####
    import struct
    from types import *
    #---------------------------------------------
    class top_tsv:
    name = ''
    file_name = ''
    list = []
    version = ''

    frombin_map = [('',{'v':0})]
    def __init__(self, file_name=0, version=0):
      if file_name == 0:
       self.file_name = toptablefolder+self.__class__.__name__
      else:
       self.file_name = file_name
      if (version == 0):
       self.version = toptableversion
      else:
       self.version = version
      self.list = []
      self.frombin_map = [('',{'v':0})]

    def unencrypt(self):
      item = []
      #Load data
      file = open(self.file_name+'.bin', 'rb')
      data = bytearray(file.read())
      file.close()

      i = 0
      array_size = int(list(struct.unpack_from('<i',data[i:i+4]))[0])
      rdata = data[i:i+4]
      data = data[i+4:len(data)]
      m = 0
      k = 0
      l = len(data)//array_size

      #2.2 encryption
      if ((self.version >= 5) and ((self.__class__.__name__ != 'magicsingleinfo') and (self.__class__.__name__ != 'magicgroupinfo') and (self.__class__.__name__ != 'resourceinfo') and (self.__class__.__name__ != 'terraininfo'))):
       newbytes = bytes.fromhex('98 9D 9F 68 E0 66 AB 70 E9 D1 E0 E0 CB DD D1 CB D5 CF')
      while(k<l):
       item = data[i:i+array_size]
       i = i+array_size
       if ((self.version >= 5) and ((self.__class__.__name__ != 'magicsingleinfo') and (self.__class__.__name__ != 'magicgroupinfo') and (self.__class__.__name__ != 'resourceinfo') and (self.__class__.__name__ != 'terraininfo'))):
            for m,c in enumerate(item):
            j = m % len(newbytes)
            item[m] = ((item[m] - newbytes[j]) + 256) % 256
       rdata = rdata + item
       k = k + 1
      m = 0
      file = open(self.file_name+'-un.bin', 'wb')
      file.write(rdata)
      file.close()

    def load_bin_data(self):
      array = []
      item = []
      addresses = []
      #Load structure (calculate size)

      struct_type_map={
       "char":"c",
       "byte":"b",
       "ubyte":"B",
       "_bool":"?",
       "short":"h",
       "ushort":"H",
       "int":"i",
       "uint":"I",
       "long":"l",
       "ulong":"L",
       "quad":"q",
       "uquad":"Q",
       "float":"f",
       "double":"d",
       "str":"s",
       "color":"B",
       "rcolor":"B",
      }
      struct_vars = {'t':'','s':1,'l':1,'stp':1,'f':-1,'v':-1,'lpad':0,'rpad':0,'sa':-1,'sap':-1,'ea':-1,'eap':-1,'st':'','lm':0,'sm':0,'smb':0,'smea':0,'sv':0,'func':0}
      #initialize addresses
      struct_init_address = 0
      struct_limit_address = 0
      struct_marked_addresses = [0,0,0,0,0,0]
      struct_func_indexes = []

      for i, v in enumerate(list(zip(*self.frombin_map))[1]):
       struct_item = struct_vars.copy()
       struct_item.update(v)
       if struct_item['smb']>=1:
            struct_marked_addresses[struct_item['smb']] = struct_init_address
       if struct_item['lm']>=1:
            struct_init_address = struct_marked_addresses[struct_item['lm']]
       if struct_item['sm']>=1:
            struct_marked_addresses[struct_item['sm']] = struct_init_address
       if (type(struct_item['func']) == FunctionType):
            struct_func_indexes.append(i)
       elif (struct_item['v'] == -1):
            if type(struct_item['t']) == tuple:
            struct_item['s'] = len(struct_item['t'])
            struct_item['st'] = []
            for j,t in enumerate(struct_item['t']):
            struct_item['st'].append(struct_type_map[struct_item['t'][j]])
            struct_item['st'] = tuple(struct_item['st'])
            struct_item['s'] = len(struct_item['st'])
            else:
            struct_item['st'] = struct_type_map[struct_item['t']]
            if ((struct_item['t'] == 'color') or (struct_item['t'] == 'rcolor')):
            struct_item['s'] = 3
            struct_item['sa'] = struct_init_address
            struct_item['sap'] = struct_item['sa'] + struct_item['lpad']
            struct_item['ea'] = struct_item['sap']
            if type(struct_item['t']) == tuple:
            for j,t in enumerate(struct_item['t']):
            struct_item['ea'] = struct_item['ea'] + struct.calcsize(struct_item['st'][j]) * ((struct_item['stp'] * struct_item['l'])-(struct_item['stp']-1))
            else:
            struct_item['ea'] = struct_item['ea'] + struct.calcsize(struct_item['st']) * ((struct_item['s'] * struct_item['stp'] * struct_item['l'])-(struct_item['stp']-1))
            if struct_item['smea']>=1:
            struct_marked_addresses[struct_item['smea']] = struct_item['ea']
            struct_item['eap'] = struct_item['ea'] + struct_item['rpad']
            struct_init_address = struct_item['eap']
            if (struct_init_address > struct_limit_address):
            struct_limit_address = struct_init_address
            #print(struct_item)

       self.frombin_map[i] = (self.frombin_map[i][0],struct_item)
      struct_size = struct_limit_address

      #Load data
      file = open(self.file_name+'.bin', 'rb')
      data = bytearray(file.read())
      file.close()

      i = 0
      k = 0
      array_size = int(list(struct.unpack_from('<i',data[i:i+4]))[0])
      if array_size != struct_size:
       print(self.file_name+'.bin: Actual array size ('+str(array_size)+') doesn''t match structure size ('+str(struct_size)+')')
       raise 'Size error.'
      data = data[i+4:len(data)]
      m = 0
      k = 0
      l = len(data)//struct_size

      #2.2 encryption
      if ((self.version >= 5) and ((self.__class__.__name__ != 'magicsingleinfo') and (self.__class__.__name__ != 'magicgroupinfo') and (self.__class__.__name__ != 'resourceinfo') and (self.__class__.__name__ != 'terraininfo'))):
       newbytes = bytes.fromhex('98 9D 9F 68 E0 66 AB 70 E9 D1 E0 E0 CB DD D1 CB D5 CF')
      while(k<l):
       item = data[i:i+struct_size]
       i = i+struct_size
       if ((self.version >= 5) and ((self.__class__.__name__ != 'magicsingleinfo') and (self.__class__.__name__ != 'magicgroupinfo') and (self.__class__.__name__ != 'resourceinfo') and (self.__class__.__name__ != 'terraininfo'))):
            for m,c in enumerate(item):
            j = m % len(newbytes)
            item[m] = ((item[m] - newbytes[j]) + 256) % 256
       array.append(item)
       k = k + 1
      m = 0

      #Associate the data with the structure
      self.list = []
      self.list.append(list(zip(*self.frombin_map))[0])
      for y,rawrow in enumerate(array):
       row = []
       for x,cell_struct in enumerate(list(zip(*self.frombin_map))[1]):
            if type(cell_struct['func']) == FunctionType:
            cell = []
            cell.append('0')
            row.append(self.transformtostr(cell,**cell_struct))
            else:
            cell = []
            if (cell_struct['v'] == -1):
            i = cell_struct['sap']
            for j in range(cell_struct['l']):
            processed_data=list(struct.unpack_from('<'+str((cell_struct['s']//len(cell_struct['st']))*cell_struct['stp'])+"".join(cell_struct['st']),rawrow,i))[::cell_struct['stp']]
            #if (x == 4) and (y == 70):
            # #print(cell_struct['s'])
            cell.append(processed_data)
            i=i+cell_struct['s']*struct.calcsize("".join(cell_struct['st']))*cell_struct['stp'] #sizeof here
            if (cell_struct['t'] == 'rcolor'):
            cell[0].reverse()
            else:
            cell.append(cell_struct['v'])
            #if y == 70:
            # print(cell) #'s':0x02,'l':0x08
            row.append(self.transformtostr(cell,**cell_struct))
       self.list.append(row)
      for x,row in enumerate(self.list):
       if x>0:
            for func_index in struct_func_indexes:
            self.list[x][func_index] = list(zip(*self.frombin_map))[1][func_index]['func'](func_index, row)

            deletions = 0
            for z,struct_item_name in enumerate(list(zip(*self.frombin_map))[0]):
            if (struct_item_name == ''):
            del self.list[x][z-deletions]
            deletions = deletions + 1
      return
    def i(self,x):
      for i,v in enumerate(self.list):
       if(x==v):
            return i
            break
      return -1
    def j(self,x):
      for i,v in enumerate(list(zip(*self.frombin_map))[0]):
       if(x==v):
            return i
            break
      return -1
    def remap(self,v):
      for i,n in enumerate(list(zip(*v))[0]):
       if self.j(n) == -1:
            self.frombin_map.append((list(zip(*v))[0][i],list(zip(*v))[1][i]))
       else:
            if (list(zip(*v))[1][i] == {}):
            del self.frombin_map[self.j(n)]
            else:
            self.frombin_map[self.j(n)] = (list(zip(*v))[0][i],list(zip(*v))[1][i])
    def bintotsv(self):
      file = open(self.file_name+'.txt', 'wt', encoding=toptableencoding)
      for i,a in enumerate(self.list):
       a=list(a)
       if (i==0):
            deletions = 0
            for z,item in enumerate(a[:]):
            if (item == ''):
            del a[z-deletions]
            deletions = deletions + 1
            file.write('//'+'\t'.join(a))
       else:
            #print(a)
            file.write('\n'+'\t'.join(a))
      file.close()
      return self
      def trim_nullbytestr(string, flag=0): #flag=1, return "0" when string is empty
       result = string
       for i,byte in enumerate(string[:]):
            if byte == '\00':
            result = string[:i]
            break
       if (flag & 1) and ((string == '\00') or (string == '')):
            result = '0'
       return result
    def transformtostr(self,result,t,s,l,stp,f,v,ea,eap,lpad,rpad,sa,sap,st,sm,lm,smb,smea,sv,func):
      if v != -1:
       return str(v)
      _type = t
      j = 0
      for n,v in enumerate(result[:]):
       m = 0
       if type(t) == tuple:
            _type = t[j]
       is_integer = not((_type=="float") or (_type=="double") or (_type=="str") or (_type=="char") or (_type=="_bool"))
       if is_integer:
            if f==-1:
            f=0
       for k,w in enumerate(v[:]):
            if is_integer:
            #Result: flag=0x0001 = remove FF's, #flag=0x0002 = cut file defect bytes, #flag=0x0004 = remove 0's
            if ((((f & 0x4) and (w == 0))) or

            ((f & 0x1) and ((w == (2**8)-1) or (w == (2**16)-1) or (w == (2**32)-1) or (w == (2**64)-1) or (w == -1))) or
            ((f & 0x2) and ((((_type=="byte") or (_type=="ubyte")) and (w == (2**8)-51)) or (((_type=="short") or (_type=="ushort")) and (w == (2**16)-12851)) or (((_type=="long") or (_type=="ulong")) and (w == (2**32)-842150451)) or (((_type=="quad") or (_type=="uquad")) and (w == (2**64)-3617008641903833651))))):
            del result[j][m]
            m=m-1
            else:
            if (f & 0x2 and w == 0):
            result[j] = result[j][:m]
            break
            result[j][m]=str(result[j][m])
            m=m+1
            if (_type=="float"):
            if f==-1:
            f=3
            result[j][k]=str(round(float(w),f))
            if (_type=="str"):
            if f==-1:
            f=0
            if (w[0] == 205) and (w[1] == 205):
            result[j][m] = ''
            else:
            result[j][m] = w.decode('gbk','ignore')
            for o,x in enumerate(result[j][m]):
            if x == '\00':
            result[j][m] = result[j][m][:o]
            break
            #result[j][m] = result[j][m].strip()
            if ((f & 1) and (result[j][m] == '')):
            result = '0'
       if (result[j] != '0'):
            result[j] = ','.join(result[j])
       if is_integer:
            if (result[j] == ''):
            result[j] = '0'
       j=j+1
      if (_type=="str"):
       result = ','.join(result)
       if ((f & 1) and (result == '')):
            result = '0'
      else:
       result = ';'.join(result)
      if is_integer:
       if (result == ''):
            result = '0'
      return result
]
for c in toptablebins:
myc = c()
try:
  myc.load_bin_data()
except IOError:
  print('"'+myc.file_name+'.bin'+'" doesn''t exist, skipping...')
myc.bintotsv()

these are a few lines below and above line 131 which is the error

   for j,t in enumerate(struct_item['t']):
    struct_item['st'].append(struct_type_map[struct_item['t'][j]])
    struct_item['st'] = tuple(struct_item['st'])
    struct_item['s'] = len(struct_item['st'])
    else:   <--- this is 131
    struct_item['st'] = struct_type_map[struct_item['t']]
    if ((struct_item['t'] == 'color') or (struct_item['t'] == 'rcolor')):
    struct_item['s'] = 3
    struct_item['sa'] = struct_init_address
    struct_item['sap'] = struct_item['sa'] + struct_item['lpad']
    struct_item['ea'] = struct_item['sap']
    if type(struct_item['t']) == tuple:
    for j,t in enumerate(struct_item['t']):
    struct_item['ea'] = struct_item['ea'] + struct.calcsize(struct_item['st'][j]) * ((struct_item['stp'] * struct_item['l'])-(struct_item['stp']-1))

Answer 1

This seems a bit weird:

l = len(data)//struct_size

You really need to post the traceback the the interpreter is giving you - it makes finding the error much easier.

Answer 2

It doesn't look like the you have the proper indention. Remember, in Python, whitespace is very very important.

The problem section of code should probably start looking something like:

       elif (struct_item['v'] == -1):
          if type(struct_item['t']) == tuple:
              struct_item['s'] = len(struct_item['t'])
              struct_item['st'] = []
              for j,t in enumerate(struct_item['t']):
                  struct_item['st'].append(struct_type_map[struct_item['t'][j]])
                  struct_item['st'] = tuple(struct_item['st'])
                  struct_item['s'] = len(struct_item['st'])