#!/usr/bin/env python
# Copyright 2009 The Go Authors. All rights reserved.
# Use of this source code is governed by a BSD-style
# license that can be found in the LICENSE file.

from xml.etree.cElementTree import *
from os.path import basename, exists
import getopt
import sys
import re

_ns = None

outfile = None
golines = []
def go(fmt, *args):
	golines.append(fmt % args)

namere = re.compile('([A-Z0-9][a-z]+|[A-Z0-9]+(?![a-z])|[a-z]+)')
allcaps = re.compile('^[A-Z0-9]+$')

sizeoftab = {
	"byte": 1,
	"int8": 1,
	"uint8": 1,
	"int16": 2,
	"uint16": 2,
	"int32": 4,
	"uint32": 4,
	"float32": 4,
	"float64": 8,
	"Id": 4,
	"Keysym": 4,
	"Timestamp": 4,
}

def sizeof(t):
	if t in sizeoftab:
		return sizeoftab[t]
	return 4

symbols = []

def readsymbols(filename):
	symbols.append("XXX Dummy XXX")
	if exists(filename):
		for line in open(filename, 'r').readlines():
			symbols.append(line.strip())

#
# Name munging crap for names, enums and types.
#

mangletab = {
	"int8_t":	"int8",
	"uint8_t":	"byte",
	"uint16_t":	"uint16",
	"uint32_t":	"uint32",
	"int16_t":	"int16",
	"int32_t":	"int32",
	"float":		"float32",
	"double":	"float64",
	"char":		"byte",
	"void":		"byte",
	'VISUALTYPE':	'VisualInfo',
	'DEPTH':		'DepthInfo',
	'SCREEN':	'ScreenInfo',
	'Setup':		'SetupInfo',
	'WINDOW':	'Id',
}

def mangle(str):
	if str in mangletab:
		return mangletab[str]
	return str

def camel(str):
	return str[0].upper() + str[1:]
def uncamel(str):
	return str[0].lower() + str[1:]

def nitem(str):
	split = namere.finditer(str)
	return ''.join([camel(match.group(0)) for match in split])

def titem(str):
	str = mangle(str)
	if str in sizeoftab:
		return str
	if allcaps.match(str):
		return str.capitalize()
	return nitem(str)

def n(list):
	"Mangle name (JoinedCamelCase) and chop off 'xcb' prefix."
	if len(list) == 1:
		parts = [nitem(list[0])]
	else:
		parts = [nitem(x) for x in list[1:]]
	return ''.join(parts)

def t(list):
	"Mangle name (JoinedCamelCase) and chop off 'xcb' prefix. Preserve primitive type names."
	if len(list) == 1:
		return titem(list[0])
	else:
		parts = [titem(x) for x in list[1:]]
	return ''.join(parts)

#
# Various helper functions
#

def go_type_setup(self, name, postfix):
	'''
	Sets up all the Go-related state by adding additional data fields to
	all Field and Type objects. Here is where we figure out most of our
	variable and function names.

	Recurses into child fields and list member types.
	'''
	# Do all the various names in advance
	self.c_type = t(name + postfix)
	self.c_request_name = n(name)
	self.c_reply_name = n(name + ('Reply',))
	self.c_reply_type = t(name + ('Reply',))

	if not self.is_container:
		return
	
	offset = 0
	for field in self.fields:
		go_type_setup(field.type, field.field_type, ())
		if field.type.is_list:
			go_type_setup(field.type.member, field.field_type, ())
		field.c_field_type = t(field.field_type)
		field.c_field_name = n((field.field_name,))
		field.c_subscript = '[%d]' % field.type.nmemb if (field.type.nmemb > 1) else ''
		field.c_pointer = ' ' if field.type.nmemb == 1 else '[]'
		field.c_offset = offset
		if field.type.fixed_size():
			offset += field.type.size * field.type.nmemb

def go_accessor_length(expr, prefix, iswriting):
	'''
	Figures out what C code is needed to get a length field.
	For fields that follow a variable-length field, use the accessor.
	Otherwise, just reference the structure field directly.
	'''
	prefarrow = '' if prefix == '' else prefix + '.'
	if expr.lenfield_name != None:
		lenstr = prefarrow + n((expr.lenfield_name,))
		if iswriting and lenstr.endswith("Len"):
			# chop off ...Len and refer to len(array) instead
			return "len(" +   lenstr[:-3] + ")"
		return "int(" + lenstr + ")"
	else:
		return str(expr.nmemb)

def go_accessor_expr(expr, prefix, iswriting):
	'''
	Figures out what C code is needed to get the length of a list field.
	Recurses for math operations.
	Returns bitcount for value-mask fields.
	Otherwise, uses the value of the length field.
	'''
	lenexp = go_accessor_length(expr, prefix, iswriting)
	if expr.op != None:
		return '(' + go_accessor_expr(expr.lhs, prefix, iswriting) + ' ' + expr.op + ' ' + go_accessor_expr(expr.rhs, prefix, iswriting) + ')'
	elif expr.bitfield:
		return 'popCount(' + lenexp + ')'
	else:
		return lenexp

def go_complex(self, fieldlist=None):
	'''
	Helper function for handling all structure types.
	Called for all structs, requests, replies, events, errors.
	'''
	if self.is_union:
		go('type %s struct /*union */ {', self.c_type)
	else:
		go('type %s struct {', self.c_type)
	if not fieldlist:
		fieldlist = self.fields
	for field in fieldlist:
		if field.type.is_pad:
			continue
		if field.wire and field.type.fixed_size():
			go('	%s %s%s;', field.c_field_name, field.c_subscript, field.c_field_type)
		if field.wire and not field.type.fixed_size():
			go('	%s []%s;', field.c_field_name, field.c_field_type)
	go('}')
	go('')

def go_get(dst, ofs, typename, typesize):
	dst = "v." + dst
	if typesize == 1:
		if typename == 'byte':
			go('%s = b[%s];', dst, ofs)
		else:
			go('%s = %s(b[%s]);', dst, typename, ofs)
	elif typesize == 2:
		if typename == 'uint16':
			go('%s = get16(b[%s:]);', dst, ofs)
		else:
			go('%s = %s(get16(b[%s:]));', dst, typename, ofs)
	elif typesize == 4:
		if typename == 'uint32':
			go('%s = get32(b[%s:]);', dst, ofs)
		else:
			go('%s = %s(get32(b[%s:]));', dst, typename, ofs)
	else:
		go('get%s(b[%s:], &%s);', typename, ofs, dst)

def go_get_list(dst, ofs, typename, typesize, count):
	if typesize == 1 and typename == 'byte':
		go('copy(v.%s[0:%s], b[%s:]);', dst, count, ofs)
	else:
		go('for i := 0; i < %s; i++ {', count)
		go_get(dst + "[i]", ofs + "+i*" + str(typesize), typename, typesize)
		go('}')


def go_complex_reader_help(self, fieldlist):
	firstvar = 1
	total = 0
	for field in fieldlist:
		fieldname = field.c_field_name
		fieldtype = field.c_field_type
		if field.wire and field.type.fixed_size():
			total = field.c_offset + field.type.size * field.type.nmemb
			if field.type.is_pad:
				continue
			if field.type.nmemb == 1:
				go_get(fieldname, field.c_offset, fieldtype, field.type.size)
			else:
				go_get_list(fieldname, field.c_offset, fieldtype, field.type.size, field.type.nmemb)
		if field.wire and not field.type.fixed_size():
			lenstr = go_accessor_expr(field.type.expr, 'v', False)
			if firstvar:
				firstvar = 0
				go('offset := %d;', field.c_offset);
			else:
				go('offset = pad(offset);')
			go('v.%s = make([]%s, %s);', fieldname, fieldtype, lenstr)
			if fieldtype in sizeoftab:
				go_get_list(fieldname, "offset", fieldtype, sizeoftab[fieldtype], "len(v."+fieldname+")")
				go('offset += len(v.%s) * %d;', fieldname, sizeoftab[fieldtype])
			else:
				go('for i := 0; i < %s; i++ {', lenstr)
				go('	offset += get%s(b[offset:], &v.%s[i]);', fieldtype, fieldname)
				go('}')
	if not firstvar:
		return 'offset'
	return str(total)

def go_complex_reader(self):
	go('func get%s(b []byte, v *%s) int {', self.c_type, self.c_type)
	go('	return %s;', go_complex_reader_help(self, self.fields))
	go('}')
	go('')
	
def structsize(fieldlist):
	fixedtotal = 0
	for field in fieldlist:
		if field.wire and field.type.fixed_size():
			fixedtotal += field.type.size * field.type.nmemb
	return fixedtotal

def go_put(src, ofs, typename, typesize):
	if typesize == 1:
		if typename == 'byte':
			go('b[%s] = %s;', ofs, src)
		else:
			go('b[%s] = byte(%s);', ofs, src)
	elif typesize == 2:
		if typename == 'uint16':
			go('put16(b[%s:], %s);', ofs, src)
		else:
			go('put16(b[%s:], uint16(%s));', ofs, src)
	elif typesize == 4:
		if typename == 'uint32':
			go('put32(b[%s:], %s);', ofs, src)
		else:
			go('put32(b[%s:], uint32(%s));', ofs, src)
	else:
		go('put%s(b[%s:], %s);', typename, ofs, src)


def go_complex_writer_help(fieldlist, prefix=''):
	prefarrow = '' if prefix == '' else prefix + '.'
	for field in fieldlist:
		fieldname = prefarrow + field.c_field_name
		fieldtype = field.c_field_type
		if fieldname.endswith("Len"):
			fieldname = "len(%s)" % fieldname[:-3]
			fieldtype = "(exp)"
		if not field.type.fixed_size():
			continue
		if field.type.is_expr:
			expstr = go_accessor_expr(field.type.expr, prefix, True)
			go_put(expstr, field.c_offset, "(exp)", field.type.size)
		elif not field.type.is_pad:
			if field.type.nmemb == 1:
				go_put(fieldname, field.c_offset, fieldtype, field.type.size)
			else:
				go('	copy(b[%d:%d], %s);', field.c_offset, field.c_offset + field.type.nmemb, fieldname)

def go_complex_writer_arguments(param_fields):
	out = []
	for field in param_fields:
		namestr = field.c_field_name
		typestr = field.c_pointer + t(field.field_type)
		if typestr == '[]byte' and namestr == 'Name':
			typestr = 'string'
		out.append(namestr + ' ' + typestr)
	go('	' + ', '.join(out))

def go_complex_writer_arguments_names(param_fields):
	out = []
	for field in param_fields:
		out.append(field.c_field_name)
	return ', '.join(out)

def go_complex_writer(self, name, void):
	func_name = self.c_request_name

	param_fields = []
	wire_fields = []
	for field in self.fields:
		if field.visible:
			# _len is taken from the list directly
			if not field.field_name.endswith("_len"):
				# The field should appear as a call parameter
				param_fields.append(field)
		if field.wire and not field.auto:
			# We need to set the field up in the structure
			wire_fields.append(field)
	
	if void:
		go('func (c *Conn) %s(', func_name)
		go_complex_writer_arguments(param_fields)
		go(') {')
	else:
		go('func (c *Conn) %sRequest(', func_name)
		go_complex_writer_arguments(param_fields)
		go(') Cookie {')
	
	fixedtotal = structsize(self.fields)
	if fixedtotal <= 32:
		go('	b := c.scratch[0:%d];', fixedtotal)
	else:
		go('	b := make([]byte, %d);', fixedtotal)
	firstvar = 0
	for field in wire_fields:
		if not field.type.fixed_size():
			if not firstvar:
				firstvar = 1
				go('	n := %d;', fixedtotal)
			go('	n += pad(%s * %d);', go_accessor_expr(field.type.expr, '', True), field.type.size)
	if not firstvar:
		go('	put16(b[2:], %d);', fixedtotal / 4)
	else:
		go('	put16(b[2:], uint16(n / 4));')
	go('	b[0] = %s;', self.opcode)
	go_complex_writer_help(wire_fields)
	if not void:
		if firstvar:
			go('	cookie := c.sendRequest(b);')
		else:
			go('	return c.sendRequest(b);')
	else:
		go('	c.sendRequest(b);')
	
	# send extra data
	for field in param_fields:
		if not field.type.fixed_size():
			if field.type.is_list:
				fieldname = field.c_field_name
				lenstr = go_accessor_expr(field.type.expr, '', True)
				if t(field.field_type) == 'byte':
					if fieldname == 'Name':
						go('	c.sendString(%s);', fieldname)
					else:
						go('	c.sendBytes(%s[0:%s]);', fieldname, lenstr)
				elif t(field.field_type) == 'uint32':
					go('	c.sendUInt32List(%s[0:%s]);', fieldname, lenstr)
				else:
					go('	c.send%sList(%s, %s);', t(field.field_type), fieldname, lenstr)
	
	if not void and firstvar:
		go('	return cookie;')
	go('}')
	go('')
	
	if not void:
		args = go_complex_writer_arguments_names(param_fields)
		go('func (c *Conn) %s(', func_name)
		go_complex_writer_arguments(param_fields)
		go(') (*%s, os.Error) {', self.c_reply_type)
		go('	return c.%sReply(c.%sRequest(%s));', func_name, func_name, args)
		go('}')
		go('')

#
# Struct definitions, readers and writers
#

def go_struct(self, name):
	go_type_setup(self, name, ())
	if symbols and t(name) not in symbols:
		go('// excluding struct %s\n', t(name))
		return
	
	if self.c_type == 'SetupRequest': return
	if self.c_type == 'SetupFailed': return
	if self.c_type == 'SetupAuthenticate': return

	go_complex(self)
	go_complex_reader(self)
	
	if self.c_type == 'Format': return
	if self.c_type == 'VisualInfo': return
	if self.c_type == 'DepthInfo': return
	if self.c_type == 'SetupInfo': return
	if self.c_type == 'ScreenInfo': return
	
	# omit variable length struct writers, they're never used
	if not self.fixed_size():
		go('// omitting variable length send%s', self.c_type)
		go('')
		return
	
	go('func (c *Conn) send%sList(list []%s, count int) {', self.c_type, self.c_type)
	go('	b0 := make([]byte, %d * count);', structsize(self.fields))
	go('	for k := 0; k < count; k++ {')
	go('	b := b0[k * %d:];', structsize(self.fields))
	go_complex_writer_help(self.fields, 'list[k]')
	go('	}')
	go('	c.sendBytes(b0);')
	go('}')
	go('')

def go_union(self, name):
	pass

#
# Request writers with reply structs and readers where needed
#

def replyfields(self):
	l = []
	for field in self.fields:
		if field.type.is_pad or not field.wire: continue
		if field.field_name == 'response_type': continue
		if field.field_name == 'sequence': continue
		if field.field_name == 'length':
			if self.c_reply_name != 'GetImageReply' and self.c_reply_name != 'GetKeyboardMappingReply':
				continue
		l.append(field)
	return l

def go_reply(self, name):
	'''
	Declares the function that returns the reply structure.
	'''
	fields = replyfields(self.reply)
	go_complex(self.reply, fields)
	go('func (c *Conn) %s(cookie Cookie) (*%s, os.Error) {', self.c_reply_name, self.c_reply_type)
	go('	b, error := c.waitForReply(cookie);')
	go('	if error != nil { return nil, error }')
	go('	v := new(%s);', self.c_reply_type)
	go_complex_reader_help(self.reply, fields)
	go('	return v, nil;')
	go('}')
	go('')

def go_request(self, name):
	'''
	Exported function that handles request declarations.
	'''
	go_type_setup(self, name, ('Request',))
	if symbols and n(name) not in symbols:
		go('// excluding request %s\n', n(name))
		return
	
	if self.reply:
		go_complex_writer(self, name, False)
		go_type_setup(self.reply, name, ('Reply',))
		go_reply(self, name)
	else:
		go_complex_writer(self, name, True)

#
# Event structs and readers
#

def eventfields(self):
	l = []
	for field in self.fields:
		if field.type.is_pad or not field.wire: continue
		if field.field_name == 'response_type': continue
		if field.field_name == 'sequence': continue
		l.append(field)
	return l

eventlist = []

def dumpeventlist():
	go('func parseEvent(buf []byte) (Event, os.Error) {')
	go('	switch buf[0] {')
	for event in eventlist:
		go('	case %s: return get%sEvent(buf), nil;', event, event)
	go('	}')
	go('	return nil, os.NewError("unknown event type");')
	go('}')

def go_event(self, name):
	'''
	Exported function that handles event declarations.
	'''
	go_type_setup(self, name, ('Event',))
	if symbols and t(name) not in symbols:
		go('// excluding event %s\n', t(name))
		return
	
	eventlist.append(n(name))
	
	go('const %s = %s', t(name), self.opcodes[name])
	go('')
	fields = eventfields(self)
	if self.name == name:
		# Structure definition
		go_complex(self, fields)
		go('func get%s(b []byte) %s {', self.c_type, self.c_type)
		go('	var v %s;', self.c_type)
		go_complex_reader_help(self, fields)
		go('	return v;')
		go('}')
		go('')
	else:
		# maybe skip this depending on how it interacts with type switching on interfaces
		go('type %s %s', n(name + ('Event',)), n(self.name + ('Event',)))
		go('')
		go('func get%s(b []byte) %s {', self.c_type, self.c_type)
		go('	return (%s)(get%s(b));', n(name + ('Event',)), n(self.name + ('Event',)))
		go('}')
		go('')

#
# Map simple types to primitive types
#

def go_simple(self, name):
	'''
	Exported function that handles cardinal type declarations.
	These are types which are typedef'd to one of the CARDx's, char, float, etc.
	We stick them into the mangletab. Lop off xcb prefix.
	'''
	go_type_setup(self, name, ())
	if self.name != name:
		if _ns.is_ext:
			name = name[2]
		else:
			name = name[1]
		if name == "KEYSYM":
			mangletab[name] = "Keysym"
		elif name == "TIMESTAMP":
			mangletab[name] = "Timestamp"
		elif self.size == 4:
			mangletab[name] = "Id"
		else:
			mangletab[name] = t(self.name)

#
# Dump enums as consts, calculate implicit values instead
# of using iota.
#

def go_enum(self, name):
	if symbols and t(name) not in symbols:
		go('// excluding enum %s\n', t(name))
		return
	go('const (')
	iota = 0
	for (enam, eval) in self.values:
		if str(eval) == '':
			iota = iota + 1
			eval = iota
		else:
			iota = int(eval)
		if name[1] == 'Atom':
			s = name[1] + "".join([x.capitalize() for x in enam.split("_")])
		else:
			s = n(name + (enam,))
		go('	%s = %s;', s, eval)
	go(')')
	go('')

errorlist = []

def dumperrorlist():
	go('var errorNames = map[byte]string{')
	for error in errorlist:
		go('	Bad%s: "%s",', error, error)
	go('}')
	go('')

def go_error(self, name):
	'''
	Exported function that handles error declarations.
	'''
	errorlist.append(n(name))
	go('const Bad%s = %s', n(name), self.opcodes[name])
	go('')

#
# Create the go file
#

def go_open(self):
	'''
	Exported function that handles module open.
	Opens the files and writes out the auto-generated code.
	'''
	global _ns
	_ns = self.namespace

	go('// This file was generated automatically from %s.', _ns.file)
	go('')
	go('package xgb')
	go('')
	go('import "os"')
	go('')
	
	if _ns.is_ext:
		go('const %s_MAJOR_VERSION = %s', _ns.ext_name.upper(), _ns.major_version)
		go('const %s_MINOR_VERSION = %s', _ns.ext_name.upper(), _ns.minor_version)
		go('')

def go_close(self):
	'''
	Exported function that handles module close.
	'''
	global outfile
	if len(eventlist) > 0:
		dumpeventlist()
	if len(errorlist) > 0:
		dumperrorlist()
	if not outfile:
		outfile = '%s.go' % _ns.header
	gofile = open(outfile, 'w')
	for line in golines:
		gofile.write(line)
		gofile.write('\n')
	gofile.close()

# Main routine starts here

# Must create an "output" dictionary before any xcbgen imports.
output = {'open'	: go_open,
		  'close'	: go_close,
		  'simple'	: go_simple,
		  'enum'	: go_enum,
		  'struct'	: go_struct,
		  'union'	: go_union,
		  'request' : go_request,
		  'event'	: go_event,
		  'error'	: go_error
		  }

# Boilerplate below this point

# Check for the argument that specifies path to the xcbgen python package.
try:
	opts, args = getopt.getopt(sys.argv[1:], 'p:s:o:')
except getopt.GetoptError, err:
	print str(err)
	print 'Usage: go_client.py [-p path] [-s symbol_list_file] [-o output.go] file.xml'
	sys.exit(1)

for (opt, arg) in opts:
	if opt == '-p':
		sys.path.append(arg)
	if opt == '-s':
		readsymbols(arg)
	if opt == '-o':
		outfile = arg

# Import the module class
try:
	from xcbgen.state import Module
except ImportError:
	print 'Failed to load the xcbgen Python package!'
	print 'Make sure that xcb/proto installed it on your Python path,'
	print 'or pass the path with -p.'
	print ''
	raise

module = Module(args[0], output)
module.register()
module.resolve()
module.generate()