title: Undefinded Syntax Error?
body: <p>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? </p>
  
  <pre><code>    #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('&lt;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 &gt;= 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&lt;l):
         item = data[i:i+array_size]
         i = i+array_size
         if ((self.version &gt;= 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']&gt;=1:
              struct_marked_addresses[struct_item['smb']] = struct_init_address
         if struct_item['lm']&gt;=1:
              struct_init_address = struct_marked_addresses[struct_item['lm']]
         if struct_item['sm']&gt;=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']&gt;=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 &gt; 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('&lt;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 &gt;= 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&lt;l):
         item = data[i:i+struct_size]
         i = i+struct_size
         if ((self.version &gt;= 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('&lt;'+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&gt;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 &amp; 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 &amp; 0x4) and (w == 0))) or
  
              ((f &amp; 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 &amp; 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 &amp; 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 &amp; 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 &amp; 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()
  </code></pre>
  
  <p>these are a few lines below and above line 131 which is the error</p>
  
  <pre><code>   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:   &lt;--- 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))
  </code></pre>