Don't determine whether to call general device-type code at startup, rather decide in the device-specific code itself. lisp/ChangeLog addition: 2008-07-07 Aidan Kehoe <kehoea@parhasard.net> Patch to make it up to the device-specific code whether various Lisp functions should be called during device creation, not relying on the startup code to decide this. Also, rename initial-window-system to initial-device-type (which makes more sense in this scheme), always set it. * startup.el (command-line): Use initial-device-type, not initial-window-system; just call #'make-device, leave the special behaviour to be done the first time a console type is initialised to be decided on by the respective console code. * x-init.el (x-app-defaults-directory): Declare that it should be bound. (x-define-dead-key): Have the macro take a DEVICE argument. (x-initialize-compose): Have the function take a DEVICE argument, and use it when checking if various keysyms are available on the keyboard. (x-initialize-keyboard): Have the function take a DEVICE argument, allowing device-specific keyboard initialisation. (make-device-early-x-entry-point-called-p): New. (make-device-late-x-entry-point-called-p): New. Rename pre-x-win-initted, x-win-initted. (make-device-early-x-entry-point): Rename init-pre-x-win, take the call to make-x-device out (it should be called from the device-creation code, not vice-versa). (make-device-late-x-entry-point): Rename init-post-x-win, have it take a DEVICE argument, use that DEVICE argument when working out what device-specific things need doing. Don't use create-console-hook in core code. * x-win-xfree86.el (x-win-init-xfree86): Take a DEVICE argument; use it. * x-win-sun.el (x-win-init-sun): Take a DEVICE argument; use it. * mule/mule-x-init.el: Remove #'init-mule-x-win, an empty function. * tty-init.el (make-device-early-tty-entry-point-called-p): New. Rename pre-tty-win-initted. (make-device-early-tty-entry-point): New. Rename init-pre-tty-win. (make-frame-after-init-entry-point): New. Rename init-post-tty-win to better reflect when it's called. * gtk-init.el (gtk-early-lisp-options-file): New. Move this path to a documented variable. (gtk-command-switch-alist): Wrap the docstring to fewer than 79 columns. (make-device-early-gtk-entry-point-called-p): New. (make-device-late-gtk-entry-point-called-p): New. Renamed gtk-pre-win-initted, gtk-post-win-initted to these. (make-device-early-gtk-entry-point): New. (make-device-late-gtk-entry-point): New. Renamed init-pre-gtk-win, init-post-gtk-win to these. Have make-device-late-gtk-entry-point take a device argument, and use it; have make-device-early-gtk-entry-point load the GTK-specific startup code, instead of doing that in C. (init-gtk-win): Deleted, functionality moved to the GTK device creation code. (gtk-define-dead-key): Have it take a DEVICE argument; use this argument. (gtk-initialize-compose): Ditto. * coding.el (set-terminal-coding-system): Correct the docstring; the function isn't broken. src/ChangeLog addition: 2008-07-07 Aidan Kehoe <kehoea@parhasard.net> Patch to make it up to the device-specific code whether various Lisp functions should be called during device creation, not relying on the startup code to decide this. Also, rename initial-window-system to initial-device-type (which makes more sense in this scheme), always set it. * redisplay.c (Vinitial_device_type): New. (Vinitial_window_system): Removed. Rename initial-window-system to initial-device type, making it a stream if we're noninteractive. Update its docstring. * device-x.c (Qmake_device_early_x_entry_point, Qmake_device_late_x_entry_point): New. Rename Qinit_pre_x_win, Qinit_post_x_win. (x_init_device): Call #'make-device-early-x-entry-point earlier, now we rely on it to find the application class and the app-defaults directory. (x_finish_init_device): Call #'make-device-late-x-entry-point with the created device. (Vx_app_defaults_directory): Always make this available, to simplify code in x-init.el. * device-tty.c (Qmake_device_early_tty_entry_point): New. Rename Qinit_pre_tty_win, rename Qinit_post_tty_win and move to frame-tty.c as Qmake_frame_after_init_entry_point. (tty_init_device): Call #'make-device-early-tty-entry-point before doing anything. * frame-tty.c (Qmake_frame_after_init_entry_point): New. * frame-tty.c (tty_after_init_frame): Have it call the better-named #'make-frame-after-init-entry-point function instead of #'init-post-tty-win (since it's called after frame, not device, creation). * device-msw.c (Qmake_device_early_mswindows_entry_point, Qmake_device_late_mswindows_entry_point): New. Rename Qinit_pre_mswindows_win, Qinit_post_mswindows_win. (mswindows_init_device): Call #'make-device-early-mswindows-entry-point here, instead of having its predecessor call us. (mswindows_finish_init_device): Call #'make-device-early-mswindows-entry-point, for symmetry with the other device types (though it's an empty function). * device-gtk.c (Qmake_device_early_gtk_entry_point, Qmake_device_late_gtk_entry_point): New. Rename Qinit_pre_gtk_win, Qinit_post_gtk_win. (gtk_init_device): Call #'make-device-early-gtk-entry-point; don't load ~/.xemacs/gtk-options.el ourselves, leave that to lisp. (gtk_finish_init_device): Call #'make-device-late-gtk-entry-point with the created device as an argument.

import string
import re
import os
import types

infile=open("xemacs.tmpl","r")

import version
import dirs
import filelist
import packages

def letter(package):
    index = packages.all.index(package)
    if index>29:
	raise "WISE error: too many components"
    return chr(ord("A")+index)

def letters(package_list):
    ret = ""
    for p in package_list: 
	ret = ret+letter(p)
    return ret

def describe(package):
    if package in packages.descriptions.keys():
	return ": "+packages.descriptions[package]
    else: return ""

def ifblock(var,val):
    return("item: If/While Statement\n  Variable=%s\n  Value=%s\n  Flags=00001010\nend\n" % (var,val))

def endblock():
    return("item: End Block\nend\n")

def setvar(var,val):
    return("item: Set Variable\n  Variable=%s\n  Value=%s\n  Flags=10000000\nend\n" % (string.upper(var), val))

def default_letters_of_category(cat):
    val = ""
    for p in packages.default:
        if packages.category_of_package(p) == cat:
            val = val + packages.letter_of_package(p)
    return val

def set_category_defaults():
    ret = ""
    for c in packages.category_names:
        ret = ret +  setvar(c, default_letters_of_category(c))
    return ret

def do_category(cat):
    ret = ifblock("COMPONENTS", packages.letter_of_category(cat))
    for pkg in packages.packages_of_category(cat):
        ret = ret + ifblock(string.upper(cat),packages.letter_of_package(pkg))
        for f in files_of_package(pkg):
            ret = ret+install_pkg_file(f)
        ret = ret + endblock()
    ret = ret + endblock()
    return ret

def files_of_package(package):
    manifest_file = dirs.packages + "\\pkginfo\\MANIFEST." + package
    manifest = open(manifest_file,"r")
    lines = manifest.readlines()
    lines = map(lambda s:s[:-1], lines)
    lines = map(lambda s:string.replace(s,'/','\\'), lines)
    return lines

def category_dialog(cat):
    npkg = len(packages.packages_of_category(cat))
    ret=""
    ret=ret+"  item: Dialog\n    Title="+packages.category_descriptions[cat]+" Packages\n"
    ret=ret+"    Width=210\n"
    ret=ret+"    Height=%d\n" % (45+npkg*10)
    ret=ret+"    Font Name=Helv\n"
    ret=ret+"    Font Size=8\n"
    ret=ret+"    item: Push Button\n"
    ret=ret+"      Rectangle=107 %d 147 %d\n" % (5+npkg*10+2, 5+npkg*10+17)
    ret=ret+"      Create Flags=01010000000000010000000000000001\n"
    ret=ret+"      Text=OK\n"
    ret=ret+"    end\n"
    ret=ret+"    item: Push Button\n"
    ret=ret+"      Rectangle=153 %d 193 %d\n" % (5+npkg*10+2, 5+npkg*10+17)
    ret=ret+"      Variable=%s\n" % string.upper(cat)
    ret=ret+"      Value=%%%s_SAVE%%\n" % string.upper(cat)
    ret=ret+"      Create Flags=01010000000000010000000000000000\n"
    ret=ret+"      Flags=0000000000000001\n"
    ret=ret+"      Text=Cancel\n"
    ret=ret+"    end\n"
    ret=ret+"    item: Checkbox\n"
    ret=ret+"      Rectangle=0 5 191 %d\n" % (10*npkg)
    ret=ret+"      Variable=%s\n"%string.upper(cat)
    ret=ret+"      Create Flags=01010000000000010000000000000011\n"
    ret=ret+"      Flags=0000000000000010\n"
    for pkg in packages.packages_of_category(cat):
        ret = ret+"      Text=%s: %s\n"%( pkg, packages.package_descriptions[pkg])
    ret=ret+"      Text=\n"
    ret=ret+"    end\n"
    ret=ret+"  end\n"
    return ret

def src_path(src,name):
    return src + "\\" + name

def dst_path(dst,name):
    return "%MAINDIR%"+"\\"+dst+"\\" + name

def install_file(name,src,dst):
    return("item: Install File\n  Source=%s\n  Destination=%s\n  Flags=0000000010000010\nend\n" % (src_path(src,name),dst_path(dst,name)))

def install_pkg_file(name):
    return install_file(name,dirs.packages,dirs.pkg_dst)

def do_package(package):
    return ifblock("COMPONENTS",letter(package)) + \
	   string.join(map(install_pkg_file,files(package)),"")+ \
	   endblock()

for line in infile.readlines():
    left=string.find(line,"<<<")
    if left>=0:
	right=string.find(line,">>>")
	expr=line[left+3:right]
	val=eval(expr)
	if type(val)==types.StringType:
	    print line[:left] + val + line[right+3:],
	elif type(val)==types.ListType:
	    for v in val:
		print line[:left] + v + line[right+3:],
    else: print line,