From 7f4f42fa100872507ca10d8e0f7d923acc266ee8 Mon Sep 17 00:00:00 2001
From: Peter Eisentraut
Date: Mon, 27 Feb 2006 16:09:50 +0000
Subject: Clean up CREATE FUNCTION syntax usage in contrib and elsewhere, in
 particular get rid of single quotes around language names and old WITH ()
 construct.

---
 contrib/btree_gist/btree_gist.sql.in           | 242 +++++++--------
 contrib/cube/cube.sql.in                       |  66 ++--
 contrib/dblink/dblink.sql.in                   | 100 +++----
 contrib/dbmirror/MirrorSetup.sql               |  68 ++---
 contrib/earthdistance/earthdistance.sql.in     |  20 +-
 contrib/fulltextindex/README.fti               |   2 +-
 contrib/fulltextindex/fti.c                    |   2 +-
 contrib/fulltextindex/fti.pl                   |   2 +-
 contrib/fulltextindex/fti.sql.in               |   2 +-
 contrib/fuzzystrmatch/README.soundex           |  59 ++--
 contrib/intarray/_int.sql.in                   |  87 +++---
 contrib/intarray/expected/_int.out             |   4 +-
 contrib/isbn_issn/isbn_issn.sql.in             |   6 +-
 contrib/ltree/README.ltree                     |   4 +-
 contrib/ltree/ltree.sql.in                     | 149 ++++-----
 contrib/mac/createoui                          |   2 +-
 contrib/pg_buffercache/pg_buffercache.sql.in   |   2 +-
 contrib/pg_freespacemap/pg_freespacemap.sql.in |   2 +-
 contrib/pg_trgm/pg_trgm.sql.in                 |  28 +-
 contrib/pgcrypto/pgcrypto.sql.in               |  70 ++---
 contrib/pgstattuple/README.pgstattuple         |   4 +-
 contrib/pgstattuple/README.pgstattuple.euc_jp  |   4 +-
 contrib/pgstattuple/pgstattuple.sql.in         |   4 +-
 contrib/seg/seg.sql.in                         |  56 ++--
 contrib/spi/autoinc.sql.in                     |   2 +-
 contrib/spi/insert_username.sql.in             |   2 +-
 contrib/spi/moddatetime.sql.in                 |   2 +-
 contrib/spi/refint.sql.in                      |   4 +-
 contrib/spi/timetravel.sql.in                  |   8 +-
 contrib/tablefunc/README.tablefunc             |   4 +-
 contrib/tablefunc/expected/tablefunc.out       |   6 +-
 contrib/tablefunc/sql/tablefunc.sql            |   6 +-
 contrib/tablefunc/tablefunc.sql.in             |  22 +-
 contrib/tsearch2/gendict/sql.IN                |   6 +-
 contrib/tsearch2/tsearch.sql.in                | 400 ++++++++++++-------------
 contrib/xml2/pgxml.sql.in                      |  26 +-
 36 files changed, 732 insertions(+), 741 deletions(-)

(limited to 'contrib')

diff --git a/contrib/btree_gist/btree_gist.sql.in b/contrib/btree_gist/btree_gist.sql.in
index e91cf1924b4..3cad6354442 100644
--- a/contrib/btree_gist/btree_gist.sql.in
+++ b/contrib/btree_gist/btree_gist.sql.in
@@ -4,12 +4,12 @@ SET search_path = public;
 CREATE FUNCTION gbtreekey4_in(cstring)
 RETURNS gbtreekey4
 AS 'MODULE_PATHNAME', 'gbtreekey_in'
-LANGUAGE 'c' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbtreekey4_out(gbtreekey4)
 RETURNS cstring
 AS 'MODULE_PATHNAME', 'gbtreekey_out'
-LANGUAGE 'c' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE gbtreekey4 (
 INTERNALLENGTH = 4,
@@ -20,12 +20,12 @@ OUTPUT = gbtreekey4_out
 CREATE FUNCTION gbtreekey8_in(cstring)
 RETURNS gbtreekey8
 AS 'MODULE_PATHNAME', 'gbtreekey_in'
-LANGUAGE 'c' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbtreekey8_out(gbtreekey8)
 RETURNS cstring
 AS 'MODULE_PATHNAME', 'gbtreekey_out'
-LANGUAGE 'c' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE gbtreekey8 (
 INTERNALLENGTH = 8,
@@ -36,12 +36,12 @@ OUTPUT = gbtreekey8_out
 CREATE FUNCTION gbtreekey16_in(cstring)
 RETURNS gbtreekey16
 AS 'MODULE_PATHNAME', 'gbtreekey_in'
-LANGUAGE 'c' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbtreekey16_out(gbtreekey16)
 RETURNS cstring
 AS 'MODULE_PATHNAME', 'gbtreekey_out'
-LANGUAGE 'c' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE gbtreekey16 (
 INTERNALLENGTH = 16,
@@ -52,12 +52,12 @@ OUTPUT = gbtreekey16_out
 CREATE FUNCTION gbtreekey32_in(cstring)
 RETURNS gbtreekey32
 AS 'MODULE_PATHNAME', 'gbtreekey_in'
-LANGUAGE 'c' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbtreekey32_out(gbtreekey32)
 RETURNS cstring
 AS 'MODULE_PATHNAME', 'gbtreekey_out'
-LANGUAGE 'c' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE gbtreekey32 (
 INTERNALLENGTH = 32,
@@ -68,12 +68,12 @@ OUTPUT = gbtreekey32_out
 CREATE FUNCTION gbtreekey_var_in(cstring)
 RETURNS gbtreekey_var
 AS 'MODULE_PATHNAME', 'gbtreekey_in'
-LANGUAGE 'c' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbtreekey_var_out(gbtreekey_var)
 RETURNS cstring
 AS 'MODULE_PATHNAME', 'gbtreekey_out'
-LANGUAGE 'c' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE gbtreekey_var (
 INTERNALLENGTH = VARIABLE,
@@ -95,42 +95,42 @@ STORAGE = EXTENDED
 CREATE FUNCTION gbt_oid_consistent(internal,oid,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_oid_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_decompress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_var_decompress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_oid_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_oid_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_oid_union(bytea, internal)
 RETURNS gbtreekey8
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_oid_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_oid_ops
@@ -162,32 +162,32 @@ AS
 CREATE FUNCTION gbt_int2_consistent(internal,int2,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int2_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int2_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_int2_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int2_union(bytea, internal)
 RETURNS gbtreekey4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int2_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_int2_ops
@@ -218,32 +218,32 @@ AS
 CREATE FUNCTION gbt_int4_consistent(internal,int4,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int4_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int4_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_int4_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int4_union(bytea, internal)
 RETURNS gbtreekey8
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int4_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_int4_ops
@@ -274,32 +274,32 @@ AS
 CREATE FUNCTION gbt_int8_consistent(internal,int8,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int8_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int8_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_int8_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int8_union(bytea, internal)
 RETURNS gbtreekey16
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int8_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_int8_ops
@@ -331,32 +331,32 @@ AS
 CREATE FUNCTION gbt_float4_consistent(internal,float4,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_float4_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_float4_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_float4_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_float4_union(bytea, internal)
 RETURNS gbtreekey8
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_float4_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_float4_ops
@@ -390,32 +390,32 @@ AS
 CREATE FUNCTION gbt_float8_consistent(internal,float8,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_float8_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_float8_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_float8_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_float8_union(bytea, internal)
 RETURNS gbtreekey16
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_float8_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_float8_ops
@@ -447,42 +447,42 @@ AS
 CREATE FUNCTION gbt_ts_consistent(internal,timestamp,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_tstz_consistent(internal,timestamptz,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
       
 CREATE FUNCTION gbt_ts_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_tstz_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_ts_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
    
 CREATE FUNCTION gbt_ts_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
       
 CREATE FUNCTION gbt_ts_union(bytea, internal)
 RETURNS gbtreekey16
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_ts_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_timestamp_ops
@@ -533,42 +533,42 @@ AS
 CREATE FUNCTION gbt_time_consistent(internal,time,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_timetz_consistent(internal,timetz,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_time_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_timetz_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_time_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
    
 CREATE FUNCTION gbt_time_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
       
 CREATE FUNCTION gbt_time_union(bytea, internal)
 RETURNS gbtreekey16
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_time_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_time_ops
@@ -617,32 +617,32 @@ AS
 CREATE FUNCTION gbt_date_consistent(internal,date,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_date_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_date_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
    
 CREATE FUNCTION gbt_date_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
       
 CREATE FUNCTION gbt_date_union(bytea, internal)
 RETURNS gbtreekey8
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_date_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_date_ops
@@ -674,37 +674,37 @@ AS
 CREATE FUNCTION gbt_intv_consistent(internal,interval,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_intv_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_intv_decompress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_intv_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
    
 CREATE FUNCTION gbt_intv_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
       
 CREATE FUNCTION gbt_intv_union(bytea, internal)
 RETURNS gbtreekey32
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_intv_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_interval_ops
@@ -735,32 +735,32 @@ AS
 CREATE FUNCTION gbt_cash_consistent(internal,money,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_cash_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_cash_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_cash_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_cash_union(bytea, internal)
 RETURNS gbtreekey8
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_cash_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_cash_ops
@@ -791,32 +791,32 @@ AS
 CREATE FUNCTION gbt_macad_consistent(internal,macaddr,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_macad_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_macad_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_macad_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_macad_union(bytea, internal)
 RETURNS gbtreekey16
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_macad_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_macaddr_ops
@@ -849,42 +849,42 @@ AS
 CREATE FUNCTION gbt_text_consistent(internal,text,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_bpchar_consistent(internal,bpchar,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_text_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_bpchar_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_text_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_text_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_text_union(bytea, internal)
 RETURNS gbtreekey_var
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_text_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_text_ops
@@ -935,32 +935,32 @@ AS
 CREATE FUNCTION gbt_bytea_consistent(internal,bytea,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_bytea_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_bytea_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_bytea_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_bytea_union(bytea, internal)
 RETURNS gbtreekey_var
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_bytea_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_bytea_ops
@@ -992,32 +992,32 @@ AS
 CREATE FUNCTION gbt_numeric_consistent(internal,numeric,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_numeric_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_numeric_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_numeric_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_numeric_union(bytea, internal)
 RETURNS gbtreekey_var
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_numeric_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_numeric_ops
@@ -1047,32 +1047,32 @@ AS
 CREATE FUNCTION gbt_bit_consistent(internal,bit,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_bit_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_bit_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_bit_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_bit_union(bytea, internal)
 RETURNS gbtreekey_var
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_bit_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_bit_ops
@@ -1124,32 +1124,32 @@ AS
 CREATE FUNCTION gbt_inet_consistent(internal,inet,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_inet_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_inet_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_inet_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_inet_union(bytea, internal)
 RETURNS gbtreekey16
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_inet_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_inet_ops
diff --git a/contrib/cube/cube.sql.in b/contrib/cube/cube.sql.in
index ff920d1f596..7b521abf156 100644
--- a/contrib/cube/cube.sql.in
+++ b/contrib/cube/cube.sql.in
@@ -7,12 +7,12 @@ SET search_path = public;
 CREATE OR REPLACE FUNCTION cube_in(cstring)
 RETURNS cube
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION cube_out(cube)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE TYPE cube (
 	INTERNALLENGTH = variable,
@@ -27,7 +27,7 @@ COMMENT ON TYPE cube IS 'multi-dimensional cube ''(FLOAT-1, FLOAT-2, ..., FLOAT-
 
 CREATE OR REPLACE FUNCTION cube(text) RETURNS cube
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube(text) IS 'convert text to cube';
 
@@ -42,70 +42,70 @@ CREATE CAST (text AS cube) WITH FUNCTION cube(text) AS ASSIGNMENT;
 CREATE OR REPLACE FUNCTION cube_eq(cube, cube)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube_eq(cube, cube) IS 'same as';
 
 CREATE OR REPLACE FUNCTION cube_ne(cube, cube)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube_ne(cube, cube) IS 'different';
 
 CREATE OR REPLACE FUNCTION cube_lt(cube, cube)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube_lt(cube, cube) IS 'lower than';
 
 CREATE OR REPLACE FUNCTION cube_gt(cube, cube)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube_gt(cube, cube) IS 'greater than';
 
 CREATE OR REPLACE FUNCTION cube_le(cube, cube)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube_le(cube, cube) IS 'lower than or equal to';
 
 CREATE OR REPLACE FUNCTION cube_ge(cube, cube)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube_ge(cube, cube) IS 'greater than or equal to';
 
 CREATE OR REPLACE FUNCTION cube_cmp(cube, cube)
 RETURNS int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube_cmp(cube, cube) IS 'btree comparison function';
 
 CREATE OR REPLACE FUNCTION cube_contains(cube, cube)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube_contains(cube, cube) IS 'contains';
 
 CREATE OR REPLACE FUNCTION cube_contained(cube, cube)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube_contained(cube, cube) IS 'contained in';
 
 CREATE OR REPLACE FUNCTION cube_overlap(cube, cube)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube_overlap(cube, cube) IS 'overlaps';
 
@@ -114,17 +114,17 @@ COMMENT ON FUNCTION cube_overlap(cube, cube) IS 'overlaps';
 CREATE OR REPLACE FUNCTION cube_union(cube, cube)
 RETURNS cube
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION cube_inter(cube, cube)
 RETURNS cube
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION cube_size(cube)
 RETURNS float8
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 
 -- Misc N-dimensional functions
@@ -134,54 +134,54 @@ LANGUAGE 'C' IMMUTABLE STRICT;
 CREATE OR REPLACE FUNCTION cube_distance(cube, cube)
 RETURNS float8
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 -- Extracting elements functions
 
 CREATE OR REPLACE FUNCTION cube_dim(cube)
 RETURNS int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION cube_ll_coord(cube, int4)
 RETURNS float8
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION cube_ur_coord(cube, int4)
 RETURNS float8
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION cube(float8) RETURNS cube
 AS 'MODULE_PATHNAME', 'cube_f8'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION cube(float8, float8) RETURNS cube
 AS 'MODULE_PATHNAME', 'cube_f8_f8'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION cube(cube, float8) RETURNS cube
 AS 'MODULE_PATHNAME', 'cube_c_f8'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION cube(cube, float8, float8) RETURNS cube
 AS 'MODULE_PATHNAME', 'cube_c_f8_f8'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 -- Test if cube is also a point
 
 CREATE OR REPLACE FUNCTION cube_is_point(cube)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 -- Increasing the size of a cube by a radius in at least n dimensions
 
 CREATE OR REPLACE FUNCTION cube_enlarge(cube, float8, int4)
 RETURNS cube
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 --
 -- OPERATORS
@@ -247,37 +247,37 @@ CREATE OPERATOR ~ (
 CREATE OR REPLACE FUNCTION g_cube_consistent(internal,cube,int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE OR REPLACE FUNCTION g_cube_compress(internal)
 RETURNS internal 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE OR REPLACE FUNCTION g_cube_decompress(internal)
 RETURNS internal 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE OR REPLACE FUNCTION g_cube_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION g_cube_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE OR REPLACE FUNCTION g_cube_union(internal, internal)
 RETURNS cube 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE OR REPLACE FUNCTION g_cube_same(cube, cube, internal)
 RETURNS internal 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 
 -- Create the operator classes for indexing
diff --git a/contrib/dblink/dblink.sql.in b/contrib/dblink/dblink.sql.in
index c38f8be8882..7cd705ba541 100644
--- a/contrib/dblink/dblink.sql.in
+++ b/contrib/dblink/dblink.sql.in
@@ -1,146 +1,146 @@
 CREATE OR REPLACE FUNCTION dblink_connect (text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_connect'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION dblink_connect (text, text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_connect'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION dblink_disconnect ()
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_disconnect'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION dblink_disconnect (text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_disconnect'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_open (text,text)
+CREATE OR REPLACE FUNCTION dblink_open (text, text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_open'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_open (text,text,bool)
+CREATE OR REPLACE FUNCTION dblink_open (text, text, boolean)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_open'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_open (text,text,text)
+CREATE OR REPLACE FUNCTION dblink_open (text, text, text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_open'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_open (text,text,text,bool)
+CREATE OR REPLACE FUNCTION dblink_open (text, text, text, boolean)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_open'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_fetch (text,int)
+CREATE OR REPLACE FUNCTION dblink_fetch (text, int)
 RETURNS setof record
 AS 'MODULE_PATHNAME','dblink_fetch'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_fetch (text,int,bool)
+CREATE OR REPLACE FUNCTION dblink_fetch (text, int, boolean)
 RETURNS setof record
 AS 'MODULE_PATHNAME','dblink_fetch'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_fetch (text,text,int)
+CREATE OR REPLACE FUNCTION dblink_fetch (text, text, int)
 RETURNS setof record
 AS 'MODULE_PATHNAME','dblink_fetch'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_fetch (text,text,int,bool)
+CREATE OR REPLACE FUNCTION dblink_fetch (text, text, int, boolean)
 RETURNS setof record
 AS 'MODULE_PATHNAME','dblink_fetch'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION dblink_close (text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_close'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_close (text,bool)
+CREATE OR REPLACE FUNCTION dblink_close (text, boolean)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_close'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_close (text,text)
+CREATE OR REPLACE FUNCTION dblink_close (text, text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_close'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_close (text,text,bool)
+CREATE OR REPLACE FUNCTION dblink_close (text, text, boolean)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_close'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink (text,text)
+CREATE OR REPLACE FUNCTION dblink (text, text)
 RETURNS setof record
 AS 'MODULE_PATHNAME','dblink_record'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink (text,text,bool)
+CREATE OR REPLACE FUNCTION dblink (text, text, boolean)
 RETURNS setof record
 AS 'MODULE_PATHNAME','dblink_record'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION dblink (text)
 RETURNS setof record
 AS 'MODULE_PATHNAME','dblink_record'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink (text,bool)
+CREATE OR REPLACE FUNCTION dblink (text, boolean)
 RETURNS setof record
 AS 'MODULE_PATHNAME','dblink_record'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_exec (text,text)
+CREATE OR REPLACE FUNCTION dblink_exec (text, text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_exec'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_exec (text,text,bool)
+CREATE OR REPLACE FUNCTION dblink_exec (text, text, boolean)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_exec'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION dblink_exec (text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_exec'
-LANGUAGE 'c' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_exec (text,bool)
+CREATE OR REPLACE FUNCTION dblink_exec (text,boolean)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_exec'
-LANGUAGE 'c' STRICT;
+LANGUAGE C STRICT;
 
-CREATE TYPE dblink_pkey_results AS (position int4, colname text);
+CREATE TYPE dblink_pkey_results AS (position int, colname text);
 
 CREATE OR REPLACE FUNCTION dblink_get_pkey (text)
 RETURNS setof dblink_pkey_results
 AS 'MODULE_PATHNAME','dblink_get_pkey'
-LANGUAGE 'c' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_build_sql_insert (text, int2vector, int4, _text, _text)
+CREATE OR REPLACE FUNCTION dblink_build_sql_insert (text, int2vector, int, _text, _text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_build_sql_insert'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_build_sql_delete (text, int2vector, int4, _text)
+CREATE OR REPLACE FUNCTION dblink_build_sql_delete (text, int2vector, int, _text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_build_sql_delete'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_build_sql_update (text, int2vector, int4, _text, _text)
+CREATE OR REPLACE FUNCTION dblink_build_sql_update (text, int2vector, int, _text, _text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_build_sql_update'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION dblink_current_query ()
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_current_query'
-LANGUAGE 'C';
+LANGUAGE C;
diff --git a/contrib/dbmirror/MirrorSetup.sql b/contrib/dbmirror/MirrorSetup.sql
index 18c5b0693e3..d4e378998a9 100644
--- a/contrib/dbmirror/MirrorSetup.sql
+++ b/contrib/dbmirror/MirrorSetup.sql
@@ -1,62 +1,54 @@
 BEGIN;
 
-
-CREATE FUNCTION "recordchange" () RETURNS trigger AS
-'$libdir/pending', 'recordchange' LANGUAGE 'C';
-
-
+CREATE FUNCTION "recordchange" () RETURNS trigger
+    AS '$libdir/pending', 'recordchange'
+    LANGUAGE C;
 
 CREATE TABLE dbmirror_MirrorHost (
-MirrorHostId serial not null,
-SlaveName varchar NOT NULL,
-PRIMARY KEY(MirrorHostId)
+    MirrorHostId serial PRIMARY KEY,
+    SlaveName varchar NOT NULL
 );
 
-
-
-
-
 CREATE TABLE dbmirror_Pending (
-SeqId serial,
-TableName Name NOT NULL,
-Op character,
-XID int4 NOT NULL,
-PRIMARY KEY (SeqId)
+    SeqId serial PRIMARY KEY,
+    TableName name NOT NULL,
+    Op character,
+    XID integer NOT NULL
 );
 
 CREATE INDEX dbmirror_Pending_XID_Index ON dbmirror_Pending (XID);
 
 CREATE TABLE dbmirror_PendingData (
-SeqId int4 NOT NULL,
-IsKey bool NOT NULL,
-Data varchar,
-PRIMARY KEY (SeqId, IsKey) ,
-FOREIGN KEY (SeqId) REFERENCES dbmirror_Pending (SeqId) ON UPDATE CASCADE  ON DELETE CASCADE
+    SeqId integer NOT NULL,
+    IsKey boolean NOT NULL,
+    Data varchar,
+    PRIMARY KEY (SeqId, IsKey) ,
+    FOREIGN KEY (SeqId) REFERENCES dbmirror_Pending (SeqId) ON UPDATE CASCADE  ON DELETE CASCADE
 );
 
-
 CREATE TABLE dbmirror_MirroredTransaction (
-XID int4 NOT NULL,
-LastSeqId int4 NOT NULL,
-MirrorHostId int4 NOT NULL,
-PRIMARY KEY  (XID,MirrorHostId),
-FOREIGN KEY (MirrorHostId) REFERENCES dbmirror_MirrorHost (MirrorHostId) ON UPDATE CASCADE ON DELETE CASCADE,
-FOREIGN KEY (LastSeqId) REFERENCES dbmirror_Pending (SeqId)  ON UPDATE
-CASCADE ON DELETE CASCADE
+    XID integer NOT NULL,
+    LastSeqId integer NOT NULL,
+    MirrorHostId integer NOT NULL,
+    PRIMARY KEY (XID, MirrorHostId),
+    FOREIGN KEY (MirrorHostId) REFERENCES dbmirror_MirrorHost (MirrorHostId) ON UPDATE CASCADE ON DELETE CASCADE,
+    FOREIGN KEY (LastSeqId) REFERENCES dbmirror_Pending (SeqId)  ON UPDATE CASCADE ON DELETE CASCADE
 );
 
-
 UPDATE pg_proc SET proname='nextval_pg' WHERE proname='nextval';
 
-CREATE FUNCTION pg_catalog.nextval(regclass) RETURNS int8 AS
-  '$libdir/pending', 'nextval_mirror' LANGUAGE 'C' STRICT;
-
+CREATE FUNCTION pg_catalog.nextval(regclass) RETURNS bigint
+    AS '$libdir/pending', 'nextval_mirror'
+    LANGUAGE C STRICT;
 
 UPDATE pg_proc set proname='setval_pg' WHERE proname='setval';
 
-CREATE FUNCTION pg_catalog.setval(regclass, int8, boolean) RETURNS int8 AS
-  '$libdir/pending', 'setval3_mirror' LANGUAGE 'C' STRICT;
-CREATE FUNCTION pg_catalog.setval(regclass, int8) RETURNS int8 AS
-  '$libdir/pending', 'setval_mirror' LANGUAGE 'C' STRICT;
+CREATE FUNCTION pg_catalog.setval(regclass, bigint, boolean) RETURNS bigint
+    AS '$libdir/pending', 'setval3_mirror'
+    LANGUAGE C STRICT;
+
+CREATE FUNCTION pg_catalog.setval(regclass, bigint) RETURNS bigint
+    AS '$libdir/pending', 'setval_mirror'
+    LANGUAGE C STRICT;
 
 COMMIT;
diff --git a/contrib/earthdistance/earthdistance.sql.in b/contrib/earthdistance/earthdistance.sql.in
index b5de7534434..3811b1d77f5 100644
--- a/contrib/earthdistance/earthdistance.sql.in
+++ b/contrib/earthdistance/earthdistance.sql.in
@@ -8,7 +8,7 @@ SET search_path = public;
 -- in order to use different units (or a better value for the Earth's radius).
 
 CREATE OR REPLACE FUNCTION earth() RETURNS float8
-LANGUAGE 'sql' IMMUTABLE
+LANGUAGE SQL IMMUTABLE
 AS 'SELECT \'6378168\'::float8';
 
 -- Astromers may want to change the earth function so that distances will be
@@ -17,7 +17,7 @@ AS 'SELECT \'6378168\'::float8';
 -- tests.
 --
 -- CREATE OR REPLACE FUNCTION earth() RETURNS float8
--- LANGUAGE 'sql' IMMUTABLE
+-- LANGUAGE SQL IMMUTABLE
 -- AS 'SELECT 180/pi()';
 
 -- Define domain for locations on the surface of the earth using a cube
@@ -35,43 +35,43 @@ CREATE DOMAIN earth AS cube
 
 CREATE OR REPLACE FUNCTION sec_to_gc(float8) 
 RETURNS float8
-LANGUAGE 'sql'
+LANGUAGE SQL
 IMMUTABLE STRICT
 AS 'SELECT CASE WHEN $1 < 0 THEN 0::float8 WHEN $1/(2*earth()) > 1 THEN pi()*earth() ELSE 2*earth()*asin($1/(2*earth())) END';
 
 CREATE OR REPLACE FUNCTION gc_to_sec(float8)
 RETURNS float8
-LANGUAGE 'sql'
+LANGUAGE SQL
 IMMUTABLE STRICT
 AS 'SELECT CASE WHEN $1 < 0 THEN 0::float8 WHEN $1/earth() > pi() THEN 2*earth() ELSE 2*earth()*sin($1/(2*earth())) END';
 
 CREATE OR REPLACE FUNCTION ll_to_earth(float8, float8)
 RETURNS earth
-LANGUAGE 'sql'
+LANGUAGE SQL
 IMMUTABLE STRICT
 AS 'SELECT cube(cube(cube(earth()*cos(radians($1))*cos(radians($2))),earth()*cos(radians($1))*sin(radians($2))),earth()*sin(radians($1)))::earth';
 
 CREATE OR REPLACE FUNCTION latitude(earth)
 RETURNS float8
-LANGUAGE 'sql'
+LANGUAGE SQL
 IMMUTABLE STRICT
 AS 'SELECT CASE WHEN cube_ll_coord($1, 3)/earth() < -1 THEN -90::float8 WHEN cube_ll_coord($1, 3)/earth() > 1 THEN 90::float8 ELSE degrees(asin(cube_ll_coord($1, 3)/earth())) END';
 
 CREATE OR REPLACE FUNCTION longitude(earth)
 RETURNS float8
-LANGUAGE 'sql'
+LANGUAGE SQL
 IMMUTABLE STRICT
 AS 'SELECT degrees(atan2(cube_ll_coord($1, 2), cube_ll_coord($1, 1)))';
 
 CREATE OR REPLACE FUNCTION earth_distance(earth, earth)
 RETURNS float8
-LANGUAGE 'sql'
+LANGUAGE SQL
 IMMUTABLE STRICT
 AS 'SELECT sec_to_gc(cube_distance($1, $2))';
 
 CREATE OR REPLACE FUNCTION earth_box(earth, float8)
 RETURNS cube
-LANGUAGE 'sql'
+LANGUAGE SQL
 IMMUTABLE STRICT
 AS 'SELECT cube_enlarge($1, gc_to_sec($2), 3)';
   
@@ -79,7 +79,7 @@ AS 'SELECT cube_enlarge($1, gc_to_sec($2), 3)';
 
 CREATE OR REPLACE FUNCTION geo_distance (point, point)
 RETURNS float8
-LANGUAGE 'C' IMMUTABLE STRICT AS 'MODULE_PATHNAME';
+LANGUAGE C IMMUTABLE STRICT AS 'MODULE_PATHNAME';
 
 --------------- geo_distance as operator <@>
 
diff --git a/contrib/fulltextindex/README.fti b/contrib/fulltextindex/README.fti
index 2425288b835..c2a24096c36 100644
--- a/contrib/fulltextindex/README.fti
+++ b/contrib/fulltextindex/README.fti
@@ -58,7 +58,7 @@ sub-string will fit.
 The create the function that contains the trigger::
 
 	create function fti() returns trigger as
-	    '/path/to/fti.so' language 'C';
+	    '/path/to/fti.so' language C;
 
 And finally define the trigger on the 'cds' table:
 
diff --git a/contrib/fulltextindex/fti.c b/contrib/fulltextindex/fti.c
index a3ac6da586f..9e120dc8920 100644
--- a/contrib/fulltextindex/fti.c
+++ b/contrib/fulltextindex/fti.c
@@ -22,7 +22,7 @@
  *
  *	-- Create the SQL function based on the compiled shared object
  *	create function fti() returns trigger as
- *	  '/usr/local/pgsql/lib/contrib/fti.so' language 'C';
+ *	  '/usr/local/pgsql/lib/contrib/fti.so' language C;
  *
  *	-- Create the FTI table
  *	create table product_fti (string varchar(255), id oid) without oids;
diff --git a/contrib/fulltextindex/fti.pl b/contrib/fulltextindex/fti.pl
index 17f000149b7..4feb51964f7 100644
--- a/contrib/fulltextindex/fti.pl
+++ b/contrib/fulltextindex/fti.pl
@@ -29,7 +29,7 @@
 #
 #		create function fti() returns trigger as
 #			'/path/to/fti/file/fti.so'
-#		language 'C';
+#		language C;
 #
 #		create trigger my_fti_trigger after update or insert or delete
 #			on mytable
diff --git a/contrib/fulltextindex/fti.sql.in b/contrib/fulltextindex/fti.sql.in
index 93eff0f633d..c060ee8757e 100644
--- a/contrib/fulltextindex/fti.sql.in
+++ b/contrib/fulltextindex/fti.sql.in
@@ -3,4 +3,4 @@ SET search_path = public;
 
 CREATE OR REPLACE FUNCTION fti() RETURNS trigger AS
 	'MODULE_PATHNAME', 'fti'
-	LANGUAGE 'C' VOLATILE CALLED ON NULL INPUT;
+	LANGUAGE C VOLATILE CALLED ON NULL INPUT;
diff --git a/contrib/fuzzystrmatch/README.soundex b/contrib/fuzzystrmatch/README.soundex
index 5a58655cdcf..cb33c64469d 100644
--- a/contrib/fuzzystrmatch/README.soundex
+++ b/contrib/fuzzystrmatch/README.soundex
@@ -20,58 +20,47 @@ SELECT soundex('Anne'), soundex('Ann'), difference('Anne', 'Ann');
 SELECT soundex('Anne'), soundex('Andrew'), difference('Anne', 'Andrew');
 SELECT soundex('Anne'), soundex('Margaret'), difference('Anne', 'Margaret');
 
-CREATE TABLE s (nm text)\g
+CREATE TABLE s (nm text);
 
-insert into s values ('john')\g
-insert into s values ('joan')\g
-insert into s values ('wobbly')\g
-insert into s values ('jack')\g
+INSERT INTO s VALUES ('john');
+INSERT INTO s VALUES ('joan');
+INSERT INTO s VALUES ('wobbly');
+INSERT INTO s VALUES ('jack');
 
-select * from s
-where soundex(nm) = soundex('john')\g
+SELECT * FROM s WHERE soundex(nm) = soundex('john');
 
-select a.nm, b.nm from s a, s b
-where soundex(a.nm) = soundex(b.nm)
-and a.oid <> b.oid\g
+SELECT a.nm, b.nm FROM s a, s b WHERE soundex(a.nm) = soundex(b.nm) AND a.oid <> b.oid;
 
-CREATE FUNCTION text_sx_eq(text, text) RETURNS bool AS
+CREATE FUNCTION text_sx_eq(text, text) RETURNS boolean AS
 'select soundex($1) = soundex($2)'
-LANGUAGE 'sql'\g
+LANGUAGE SQL;
 
-CREATE FUNCTION text_sx_lt(text,text) RETURNS bool AS
+CREATE FUNCTION text_sx_lt(text, text) RETURNS boolean AS
 'select soundex($1) < soundex($2)'
-LANGUAGE 'sql'\g
+LANGUAGE SQL;
 
-CREATE FUNCTION text_sx_gt(text,text) RETURNS bool AS
+CREATE FUNCTION text_sx_gt(text, text) RETURNS boolean AS
 'select soundex($1) > soundex($2)'
-LANGUAGE 'sql';
+LANGUAGE SQL;
 
-CREATE FUNCTION text_sx_le(text,text) RETURNS bool AS
+CREATE FUNCTION text_sx_le(text, text) RETURNS boolean AS
 'select soundex($1) <= soundex($2)'
-LANGUAGE 'sql';
+LANGUAGE SQL;
 
-CREATE FUNCTION text_sx_ge(text,text) RETURNS bool AS
+CREATE FUNCTION text_sx_ge(text, text) RETURNS boolean AS
 'select soundex($1) >= soundex($2)'
-LANGUAGE 'sql';
+LANGUAGE SQL;
 
-CREATE FUNCTION text_sx_ne(text,text) RETURNS bool AS
+CREATE FUNCTION text_sx_ne(text, text) RETURNS boolean AS
 'select soundex($1) <> soundex($2)'
-LANGUAGE 'sql';
+LANGUAGE SQL;
 
-DROP OPERATOR #= (text,text)\g
+DROP OPERATOR #= (text, text);
 
-CREATE OPERATOR #= (leftarg=text, rightarg=text, procedure=text_sx_eq,
-commutator = #=)\g
+CREATE OPERATOR #= (leftarg=text, rightarg=text, procedure=text_sx_eq, commutator = #=);
 
-SELECT *
-FROM s
-WHERE text_sx_eq(nm,'john')\g
+SELECT * FROM s WHERE text_sx_eq(nm, 'john');
 
-SELECT *
-FROM s
-WHERE s.nm #= 'john';
-
-SELECT *
-FROM s
-WHERE difference(s.nm, 'john') > 2;
+SELECT * FROM s WHERE s.nm #= 'john';
 
+SELECT * FROM s WHERE difference(s.nm, 'john') > 2;
diff --git a/contrib/intarray/_int.sql.in b/contrib/intarray/_int.sql.in
index f0b35b21818..b9d33a7a43a 100644
--- a/contrib/intarray/_int.sql.in
+++ b/contrib/intarray/_int.sql.in
@@ -10,12 +10,12 @@ SET search_path = public;
 CREATE FUNCTION bqarr_in(cstring)
 RETURNS query_int
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION bqarr_out(query_int)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE query_int (
 	INTERNALLENGTH = -1,
@@ -27,20 +27,20 @@ CREATE TYPE query_int (
 CREATE FUNCTION querytree(query_int)
 RETURNS text
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 
 CREATE FUNCTION boolop(_int4, query_int)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 COMMENT ON FUNCTION boolop(_int4, query_int) IS 'boolean operation with array';
 
 CREATE FUNCTION rboolop(query_int, _int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 COMMENT ON FUNCTION rboolop(query_int, _int4) IS 'boolean operation with array';
 
@@ -72,35 +72,35 @@ CREATE OPERATOR ~~ (
 CREATE FUNCTION _int_contains(_int4, _int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 COMMENT ON FUNCTION _int_contains(_int4, _int4) IS 'contains';
 
 CREATE FUNCTION _int_contained(_int4, _int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 COMMENT ON FUNCTION _int_contained(_int4, _int4) IS 'contained in';
 
 CREATE FUNCTION _int_overlap(_int4, _int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 COMMENT ON FUNCTION _int_overlap(_int4, _int4) IS 'overlaps';
 
 CREATE FUNCTION _int_same(_int4, _int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 COMMENT ON FUNCTION _int_same(_int4, _int4) IS 'same as';
 
 CREATE FUNCTION _int_different(_int4, _int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 COMMENT ON FUNCTION _int_different(_int4, _int4) IS 'different';
 
@@ -108,12 +108,13 @@ COMMENT ON FUNCTION _int_different(_int4, _int4) IS 'different';
 
 CREATE FUNCTION _int_union(_int4, _int4)
 RETURNS _int4
-AS 'MODULE_PATHNAME' LANGUAGE 'C' WITH (isstrict);
+AS 'MODULE_PATHNAME'
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION _int_inter(_int4, _int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 --
 -- OPERATORS
@@ -172,12 +173,12 @@ CREATE OPERATOR ~ (
 CREATE FUNCTION intset(int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION icount(_int4)
 RETURNS int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR # (
 	RIGHTARG = _int4,
@@ -187,32 +188,32 @@ CREATE OPERATOR # (
 CREATE FUNCTION sort(_int4, text)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION sort(_int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION sort_asc(_int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION sort_desc(_int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION uniq(_int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION idx(_int4, int4)
 RETURNS int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR # (
 	LEFTARG = _int4,
@@ -223,17 +224,17 @@ CREATE OPERATOR # (
 CREATE FUNCTION subarray(_int4, int4, int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION subarray(_int4, int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION intarray_push_elem(_int4, int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR + (
 	LEFTARG = _int4,
@@ -244,7 +245,7 @@ CREATE OPERATOR + (
 CREATE FUNCTION intarray_push_array(_int4, _int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR + (
 	LEFTARG = _int4,
@@ -256,7 +257,7 @@ CREATE OPERATOR + (
 CREATE FUNCTION intarray_del_elem(_int4, int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR - (
 	LEFTARG = _int4,
@@ -267,7 +268,7 @@ CREATE OPERATOR - (
 CREATE FUNCTION intset_union_elem(_int4, int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR | (
 	LEFTARG = _int4,
@@ -285,7 +286,7 @@ CREATE OPERATOR | (
 CREATE FUNCTION intset_subtract(_int4, _int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR - (
 	LEFTARG = _int4,
@@ -305,37 +306,37 @@ CREATE OPERATOR & (
 CREATE FUNCTION g_int_consistent(internal,_int4,int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION g_int_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION g_int_decompress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION g_int_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION g_int_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION g_int_union(internal, internal)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION g_int_same(_int4, _int4, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 
 -- Create the operator class for indexing
@@ -364,12 +365,12 @@ DEFAULT FOR TYPE _int4 USING gist AS
 CREATE FUNCTION _intbig_in(cstring)
 RETURNS intbig_gkey
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION _intbig_out(intbig_gkey)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE intbig_gkey (
         INTERNALLENGTH = -1,
@@ -380,37 +381,37 @@ CREATE TYPE intbig_gkey (
 CREATE FUNCTION g_intbig_consistent(internal,internal,int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION g_intbig_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION g_intbig_decompress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION g_intbig_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION g_intbig_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION g_intbig_union(internal, internal)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION g_intbig_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- register the opclass for indexing (not as default)
 
diff --git a/contrib/intarray/expected/_int.out b/contrib/intarray/expected/_int.out
index 0094bdcd602..85c8d8bb142 100644
--- a/contrib/intarray/expected/_int.out
+++ b/contrib/intarray/expected/_int.out
@@ -6,9 +6,9 @@
 psql:_int.sql:13: NOTICE:  type "query_int" is not yet defined
 DETAIL:  Creating a shell type definition.
 psql:_int.sql:18: NOTICE:  argument type query_int is only a shell
-psql:_int.sql:367: NOTICE:  type "intbig_gkey" is not yet defined
+psql:_int.sql:368: NOTICE:  type "intbig_gkey" is not yet defined
 DETAIL:  Creating a shell type definition.
-psql:_int.sql:372: NOTICE:  argument type intbig_gkey is only a shell
+psql:_int.sql:373: NOTICE:  argument type intbig_gkey is only a shell
 SELECT intset(1234);
  intset 
 --------
diff --git a/contrib/isbn_issn/isbn_issn.sql.in b/contrib/isbn_issn/isbn_issn.sql.in
index 740296cdf73..1fb0b5ffb49 100644
--- a/contrib/isbn_issn/isbn_issn.sql.in
+++ b/contrib/isbn_issn/isbn_issn.sql.in
@@ -1,7 +1,7 @@
 --
 --	PostgreSQL code for ISSNs.
 --
---	$PostgreSQL: pgsql/contrib/isbn_issn/isbn_issn.sql.in,v 1.11 2005/01/29 22:35:02 tgl Exp $
+--	$PostgreSQL: pgsql/contrib/isbn_issn/isbn_issn.sql.in,v 1.12 2006/02/27 16:09:48 petere Exp $
 --
 
 -- Adjust this setting to control where the objects get created.
@@ -120,7 +120,7 @@ CREATE OPERATOR <> (
 CREATE FUNCTION issn_cmp(issn, issn)
 RETURNS integer
 AS '$libdir/isbn_issn'
-LANGUAGE c STRICT;
+LANGUAGE C STRICT;
 
 -- Create default operator class for 'issn'    --
 -- Needed to create index or primary key       --
@@ -253,7 +253,7 @@ CREATE OPERATOR <> (
 CREATE FUNCTION isbn_cmp(isbn, isbn)
 RETURNS integer
 AS '$libdir/isbn_issn'
-LANGUAGE c STRICT;
+LANGUAGE C STRICT;
 
 -- Create default operator class for 'isbn'    --
 -- Needed to create index or primary key       --
diff --git a/contrib/ltree/README.ltree b/contrib/ltree/README.ltree
index 55b15d0f822..a9d722d0514 100644
--- a/contrib/ltree/README.ltree
+++ b/contrib/ltree/README.ltree
@@ -313,7 +313,7 @@ ltreetest=# select subpath(path,0,2)||'Space'||subpath(path,2) from test where p
 We could create SQL-function:
 CREATE FUNCTION ins_label(ltree, int4, text) RETURNS ltree 
 AS 'select subpath($1,0,$2) || $3 || subpath($1,$2);'
-LANGUAGE SQL WITH (ISCACHABLE);
+LANGUAGE SQL IMMUTABLE;
 
 and previous select could be rewritten as:
 
@@ -329,7 +329,7 @@ Or with another arguments:
 
 CREATE FUNCTION ins_label(ltree, ltree, text) RETURNS ltree
 AS 'select subpath($1,0,nlevel($2)) || $3 || subpath($1,nlevel($2));'
-LANGUAGE SQL WITH (ISCACHABLE);
+LANGUAGE SQL IMMUTABLE;
 
 ltreetest=# select ins_label(path,'Top.Science'::ltree,'Space') from test where path <@ 'Top.Science.Astronomy';
                 ins_label                 
diff --git a/contrib/ltree/ltree.sql.in b/contrib/ltree/ltree.sql.in
index e80c391ab0e..8e7d5680a84 100644
--- a/contrib/ltree/ltree.sql.in
+++ b/contrib/ltree/ltree.sql.in
@@ -4,12 +4,12 @@ SET search_path = public;
 CREATE FUNCTION ltree_in(cstring)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION ltree_out(ltree)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE ltree (
 	INTERNALLENGTH = -1,
@@ -23,37 +23,37 @@ CREATE TYPE ltree (
 CREATE FUNCTION ltree_cmp(ltree,ltree)
 RETURNS int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_lt(ltree,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_le(ltree,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_eq(ltree,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_ge(ltree,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_gt(ltree,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_ne(ltree,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 
 CREATE OPERATOR < (
@@ -123,107 +123,107 @@ CREATE OPERATOR <> (
 CREATE FUNCTION subltree(ltree,int4,int4)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION subpath(ltree,int4,int4)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION subpath(ltree,int4)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION index(ltree,ltree)
 RETURNS int4
 AS 'MODULE_PATHNAME', 'ltree_index'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION index(ltree,ltree,int4)
 RETURNS int4
 AS 'MODULE_PATHNAME', 'ltree_index'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION nlevel(ltree)
 RETURNS int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree2text(ltree)
 RETURNS text
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION text2ltree(text)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION lca(_ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME','_lca'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION lca(ltree,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION lca(ltree,ltree,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION lca(ltree,ltree,ltree,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION lca(ltree,ltree,ltree,ltree,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION lca(ltree,ltree,ltree,ltree,ltree,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION lca(ltree,ltree,ltree,ltree,ltree,ltree,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION lca(ltree,ltree,ltree,ltree,ltree,ltree,ltree,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_isparent(ltree,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_risparent(ltree,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_addltree(ltree,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_addtext(ltree,text)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_textadd(text,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR @> (
         LEFTARG = ltree,
@@ -296,12 +296,12 @@ CREATE OPERATOR CLASS ltree_ops
 CREATE FUNCTION lquery_in(cstring)
 RETURNS lquery
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION lquery_out(lquery)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE lquery (
 	INTERNALLENGTH = -1,
@@ -313,12 +313,12 @@ CREATE TYPE lquery (
 CREATE FUNCTION ltq_regex(ltree,lquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltq_rregex(lquery,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR ~ (
         LEFTARG = ltree,
@@ -360,12 +360,12 @@ CREATE OPERATOR ^~ (
 CREATE FUNCTION lt_q_regex(ltree,_lquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION lt_q_rregex(_lquery,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR ? (
         LEFTARG = ltree,
@@ -407,12 +407,12 @@ CREATE OPERATOR ^? (
 CREATE FUNCTION ltxtq_in(cstring)
 RETURNS ltxtquery
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION ltxtq_out(ltxtquery)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE ltxtquery (
 	INTERNALLENGTH = -1,
@@ -426,12 +426,12 @@ CREATE TYPE ltxtquery (
 CREATE FUNCTION ltxtq_exec(ltree, ltxtquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltxtq_rexec(ltxtquery, ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR @ (
         LEFTARG = ltree,
@@ -474,12 +474,12 @@ CREATE OPERATOR ^@ (
 CREATE FUNCTION ltree_gist_in(cstring)
 RETURNS ltree_gist
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
   
 CREATE FUNCTION ltree_gist_out(ltree_gist)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
   
 CREATE TYPE ltree_gist (
 	internallength = -1,
@@ -490,19 +490,25 @@ CREATE TYPE ltree_gist (
 
 
 CREATE FUNCTION ltree_consistent(internal,internal,int2)
-RETURNS bool as 'MODULE_PATHNAME' language 'C';
+RETURNS bool as 'MODULE_PATHNAME' LANGUAGE C;
+
 CREATE FUNCTION ltree_compress(internal)
-RETURNS internal as 'MODULE_PATHNAME' language 'C';
+RETURNS internal as 'MODULE_PATHNAME' LANGUAGE C;
+
 CREATE FUNCTION ltree_decompress(internal)
-RETURNS internal as 'MODULE_PATHNAME' language 'C';
+RETURNS internal as 'MODULE_PATHNAME' LANGUAGE C;
+
 CREATE FUNCTION ltree_penalty(internal,internal,internal)
-RETURNS internal as 'MODULE_PATHNAME' language 'C' with(isstrict);
+RETURNS internal as 'MODULE_PATHNAME' LANGUAGE C RETURNS NULL ON NULL INPUT;
+
 CREATE FUNCTION ltree_picksplit(internal, internal)
-RETURNS internal as 'MODULE_PATHNAME' language 'C';
+RETURNS internal as 'MODULE_PATHNAME' LANGUAGE C;
+
 CREATE FUNCTION ltree_union(internal, internal)
-RETURNS int4 as 'MODULE_PATHNAME' language 'C';
+RETURNS int4 as 'MODULE_PATHNAME' LANGUAGE C;
+
 CREATE FUNCTION ltree_same(internal, internal, internal)
-RETURNS internal as 'MODULE_PATHNAME' language 'C';
+RETURNS internal as 'MODULE_PATHNAME' LANGUAGE C;
 
 CREATE OPERATOR CLASS gist_ltree_ops
     DEFAULT FOR TYPE ltree USING gist AS
@@ -534,52 +540,52 @@ CREATE OPERATOR CLASS gist_ltree_ops
 CREATE FUNCTION _ltree_isparent(_ltree,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION _ltree_r_isparent(ltree,_ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION _ltree_risparent(_ltree,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION _ltree_r_risparent(ltree,_ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION _ltq_regex(_ltree,lquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION _ltq_rregex(lquery,_ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION _lt_q_regex(_ltree,_lquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION _lt_q_rregex(_lquery,_ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION _ltxtq_exec(_ltree, ltxtquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION _ltxtq_rexec(ltxtquery, _ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR @> (
         LEFTARG = _ltree,
@@ -767,7 +773,7 @@ CREATE OPERATOR ^@ (
 CREATE FUNCTION _ltree_extract_isparent(_ltree,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR ?@> (
         LEFTARG = _ltree,
@@ -778,7 +784,7 @@ CREATE OPERATOR ?@> (
 CREATE FUNCTION _ltree_extract_risparent(_ltree,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR ?<@ (
         LEFTARG = _ltree,
@@ -789,7 +795,7 @@ CREATE OPERATOR ?<@ (
 CREATE FUNCTION _ltq_extract_regex(_ltree,lquery)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR ?~ (
         LEFTARG = _ltree,
@@ -800,7 +806,7 @@ CREATE OPERATOR ?~ (
 CREATE FUNCTION _ltxtq_extract_exec(_ltree,ltxtquery)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR ?@ (
         LEFTARG = _ltree,
@@ -812,27 +818,32 @@ CREATE OPERATOR ?@ (
 CREATE FUNCTION _ltree_consistent(internal,internal,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
+
 CREATE FUNCTION _ltree_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
+
 CREATE FUNCTION _ltree_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH(isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
+
 CREATE FUNCTION _ltree_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
+
 CREATE FUNCTION _ltree_union(internal, internal)
 RETURNS int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
+
 CREATE FUNCTION _ltree_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE OPERATOR CLASS gist__ltree_ops
     DEFAULT FOR TYPE _ltree USING gist AS
diff --git a/contrib/mac/createoui b/contrib/mac/createoui
index 56d81c20d36..ec1edcfa175 100755
--- a/contrib/mac/createoui
+++ b/contrib/mac/createoui
@@ -42,7 +42,7 @@ create index macoui_idx on macoui (addr);
 create function manuf (macaddr)
 	returns text as '
 		select name from macoui m where trunc(\$1) = m.addr;
-' language 'SQL';
+' language SQL;
 EOF
 
 if [ $update -gt 0 ]; then
diff --git a/contrib/pg_buffercache/pg_buffercache.sql.in b/contrib/pg_buffercache/pg_buffercache.sql.in
index 1dd0b2eae6c..85c7b2869a2 100644
--- a/contrib/pg_buffercache/pg_buffercache.sql.in
+++ b/contrib/pg_buffercache/pg_buffercache.sql.in
@@ -5,7 +5,7 @@ SET search_path = public;
 CREATE OR REPLACE FUNCTION pg_buffercache_pages()
 RETURNS SETOF RECORD
 AS 'MODULE_PATHNAME', 'pg_buffercache_pages'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create a view for convenient access.
 CREATE VIEW pg_buffercache AS
diff --git a/contrib/pg_freespacemap/pg_freespacemap.sql.in b/contrib/pg_freespacemap/pg_freespacemap.sql.in
index a185186518d..26574ea1c09 100644
--- a/contrib/pg_freespacemap/pg_freespacemap.sql.in
+++ b/contrib/pg_freespacemap/pg_freespacemap.sql.in
@@ -6,7 +6,7 @@ SET search_path = public;
 CREATE OR REPLACE FUNCTION pg_freespacemap()
 RETURNS SETOF RECORD
 AS 'MODULE_PATHNAME', 'pg_freespacemap'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create a view for convenient access.
 CREATE VIEW pg_freespacemap AS
diff --git a/contrib/pg_trgm/pg_trgm.sql.in b/contrib/pg_trgm/pg_trgm.sql.in
index f38abb6e48b..6ee16f6e230 100644
--- a/contrib/pg_trgm/pg_trgm.sql.in
+++ b/contrib/pg_trgm/pg_trgm.sql.in
@@ -5,27 +5,27 @@ BEGIN;
 create function set_limit(float4)
 returns float4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 create function show_limit()
 returns float4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 create function show_trgm(text)
 returns _text
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 create function similarity(text,text)
 returns float4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 create function similarity_op(text,text)
 returns bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR % (
         LEFTARG = text,
@@ -40,12 +40,12 @@ CREATE OPERATOR % (
 CREATE FUNCTION gtrgm_in(cstring)
 RETURNS gtrgm
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gtrgm_out(gtrgm)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE gtrgm (
         INTERNALLENGTH = -1,
@@ -57,37 +57,37 @@ CREATE TYPE gtrgm (
 CREATE FUNCTION gtrgm_consistent(gtrgm,internal,int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
  
 CREATE FUNCTION gtrgm_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtrgm_decompress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtrgm_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gtrgm_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtrgm_union(bytea, internal)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtrgm_same(gtrgm, gtrgm, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- create the operator class
 CREATE OPERATOR CLASS gist_trgm_ops
diff --git a/contrib/pgcrypto/pgcrypto.sql.in b/contrib/pgcrypto/pgcrypto.sql.in
index fb3949d56e4..a6ff645c4fc 100644
--- a/contrib/pgcrypto/pgcrypto.sql.in
+++ b/contrib/pgcrypto/pgcrypto.sql.in
@@ -4,72 +4,72 @@ SET search_path = public;
 CREATE OR REPLACE FUNCTION digest(text, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pg_digest'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION digest(bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pg_digest'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION digest_exists(text)
 RETURNS bool
 AS 'MODULE_PATHNAME', 'pg_digest_exists'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION hmac(text, text, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pg_hmac'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION hmac(bytea, bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pg_hmac'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION hmac_exists(text)
 RETURNS bool
 AS 'MODULE_PATHNAME', 'pg_hmac_exists'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION crypt(text, text)
 RETURNS text
 AS 'MODULE_PATHNAME', 'pg_crypt'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION gen_salt(text)
 RETURNS text
 AS 'MODULE_PATHNAME', 'pg_gen_salt'
-LANGUAGE 'C' VOLATILE STRICT;
+LANGUAGE C VOLATILE STRICT;
 
 CREATE OR REPLACE FUNCTION gen_salt(text, int4)
 RETURNS text
 AS 'MODULE_PATHNAME', 'pg_gen_salt_rounds'
-LANGUAGE 'C' VOLATILE STRICT;
+LANGUAGE C VOLATILE STRICT;
 
 CREATE OR REPLACE FUNCTION encrypt(bytea, bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pg_encrypt'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION decrypt(bytea, bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pg_decrypt'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION encrypt_iv(bytea, bytea, bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pg_encrypt_iv'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION decrypt_iv(bytea, bytea, bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pg_decrypt_iv'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION cipher_exists(text)
 RETURNS bool
 AS 'MODULE_PATHNAME', 'pg_cipher_exists'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 --
 -- pgp_sym_encrypt(data, key)
@@ -77,12 +77,12 @@ LANGUAGE 'C' IMMUTABLE STRICT;
 CREATE OR REPLACE FUNCTION pgp_sym_encrypt(text, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_sym_encrypt_text'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION pgp_sym_encrypt_bytea(bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_sym_encrypt_bytea'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 --
 -- pgp_sym_encrypt(data, key, args)
@@ -90,12 +90,12 @@ LANGUAGE 'C' STRICT;
 CREATE OR REPLACE FUNCTION pgp_sym_encrypt(text, text, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_sym_encrypt_text'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION pgp_sym_encrypt_bytea(bytea, text, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_sym_encrypt_bytea'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 --
 -- pgp_sym_decrypt(data, key)
@@ -103,12 +103,12 @@ LANGUAGE 'C' STRICT;
 CREATE OR REPLACE FUNCTION pgp_sym_decrypt(bytea, text)
 RETURNS text
 AS 'MODULE_PATHNAME', 'pgp_sym_decrypt_text'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION pgp_sym_decrypt_bytea(bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_sym_decrypt_bytea'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 --
 -- pgp_sym_decrypt(data, key, args)
@@ -116,12 +116,12 @@ LANGUAGE 'C' IMMUTABLE STRICT;
 CREATE OR REPLACE FUNCTION pgp_sym_decrypt(bytea, text, text)
 RETURNS text
 AS 'MODULE_PATHNAME', 'pgp_sym_decrypt_text'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION pgp_sym_decrypt_bytea(bytea, text, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_sym_decrypt_bytea'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 --
 -- pgp_pub_encrypt(data, key)
@@ -129,12 +129,12 @@ LANGUAGE 'C' IMMUTABLE STRICT;
 CREATE OR REPLACE FUNCTION pgp_pub_encrypt(text, bytea)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_pub_encrypt_text'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION pgp_pub_encrypt_bytea(bytea, bytea)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_pub_encrypt_bytea'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 --
 -- pgp_pub_encrypt(data, key, args)
@@ -142,12 +142,12 @@ LANGUAGE 'C' STRICT;
 CREATE OR REPLACE FUNCTION pgp_pub_encrypt(text, bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_pub_encrypt_text'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION pgp_pub_encrypt_bytea(bytea, bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_pub_encrypt_bytea'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 --
 -- pgp_pub_decrypt(data, key)
@@ -155,12 +155,12 @@ LANGUAGE 'C' STRICT;
 CREATE OR REPLACE FUNCTION pgp_pub_decrypt(bytea, bytea)
 RETURNS text
 AS 'MODULE_PATHNAME', 'pgp_pub_decrypt_text'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION pgp_pub_decrypt_bytea(bytea, bytea)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_pub_decrypt_bytea'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 --
 -- pgp_pub_decrypt(data, key, psw)
@@ -168,12 +168,12 @@ LANGUAGE 'C' IMMUTABLE STRICT;
 CREATE OR REPLACE FUNCTION pgp_pub_decrypt(bytea, bytea, text)
 RETURNS text
 AS 'MODULE_PATHNAME', 'pgp_pub_decrypt_text'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION pgp_pub_decrypt_bytea(bytea, bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_pub_decrypt_bytea'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 --
 -- pgp_pub_decrypt(data, key, psw, arg)
@@ -181,12 +181,12 @@ LANGUAGE 'C' IMMUTABLE STRICT;
 CREATE OR REPLACE FUNCTION pgp_pub_decrypt(bytea, bytea, text, text)
 RETURNS text
 AS 'MODULE_PATHNAME', 'pgp_pub_decrypt_text'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION pgp_pub_decrypt_bytea(bytea, bytea, text, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_pub_decrypt_bytea'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 --
 -- PGP key ID
@@ -194,7 +194,7 @@ LANGUAGE 'C' IMMUTABLE STRICT;
 CREATE OR REPLACE FUNCTION pgp_key_id(bytea)
 RETURNS text
 AS 'MODULE_PATHNAME', 'pgp_key_id_w'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 --
 -- pgp armor
@@ -202,10 +202,10 @@ LANGUAGE 'C' IMMUTABLE STRICT;
 CREATE OR REPLACE FUNCTION armor(bytea)
 RETURNS text
 AS 'MODULE_PATHNAME', 'pg_armor'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION dearmor(text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pg_dearmor'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
diff --git a/contrib/pgstattuple/README.pgstattuple b/contrib/pgstattuple/README.pgstattuple
index 3e7facb80f0..7395b1ce319 100644
--- a/contrib/pgstattuple/README.pgstattuple
+++ b/contrib/pgstattuple/README.pgstattuple
@@ -45,11 +45,11 @@ free_percent		-- free space in %
 
    CREATE OR REPLACE FUNCTION pgstattuple(text) RETURNS pgstattuple_type
      AS 'MODULE_PATHNAME', 'pgstattuple'
-     LANGUAGE 'c' STRICT;
+     LANGUAGE C STRICT;
 
    CREATE OR REPLACE FUNCTION pgstattuple(oid) RETURNS pgstattuple_type
      AS 'MODULE_PATHNAME', 'pgstattuplebyid'
-     LANGUAGE 'c' STRICT;
+     LANGUAGE C STRICT;
 
    The argument is the table name (optionally it may be qualified)
    or the OID of the table.  Note that pgstattuple only returns
diff --git a/contrib/pgstattuple/README.pgstattuple.euc_jp b/contrib/pgstattuple/README.pgstattuple.euc_jp
index 40bfa8d3ac1..1c3c982b286 100644
--- a/contrib/pgstattuple/README.pgstattuple.euc_jp
+++ b/contrib/pgstattuple/README.pgstattuple.euc_jp
@@ -1,4 +1,4 @@
-$PostgreSQL: pgsql/contrib/pgstattuple/README.pgstattuple.euc_jp,v 1.5 2003/11/29 22:39:29 pgsql Exp $
+$PostgreSQL: pgsql/contrib/pgstattuple/README.pgstattuple.euc_jp,v 1.6 2006/02/27 16:09:49 petere Exp $
 
 pgstattuple README		2002/08/22 石井達夫
 
@@ -54,7 +54,7 @@ free_percent		-- 
 
    CREATE OR REPLACE FUNCTION pgstattuple(text) RETURNS pgstattuple_type
      AS 'MODULE_PATHNAME', 'pgstattuple'
-     LANGUAGE 'c' WITH (isstrict);
+     LANGUAGE C STRICT;
 
    第一引数: テーブル名
 
diff --git a/contrib/pgstattuple/pgstattuple.sql.in b/contrib/pgstattuple/pgstattuple.sql.in
index f7eac5040f9..440b978682c 100644
--- a/contrib/pgstattuple/pgstattuple.sql.in
+++ b/contrib/pgstattuple/pgstattuple.sql.in
@@ -16,9 +16,9 @@ CREATE TYPE pgstattuple_type AS (
 CREATE OR REPLACE FUNCTION pgstattuple(text)
 RETURNS pgstattuple_type
 AS 'MODULE_PATHNAME', 'pgstattuple'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION pgstattuple(oid)
 RETURNS pgstattuple_type
 AS 'MODULE_PATHNAME', 'pgstattuplebyid'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
diff --git a/contrib/seg/seg.sql.in b/contrib/seg/seg.sql.in
index ca30a30ba57..94a02224a0e 100644
--- a/contrib/seg/seg.sql.in
+++ b/contrib/seg/seg.sql.in
@@ -7,12 +7,12 @@ SET search_path = public;
 CREATE FUNCTION seg_in(cstring)
 RETURNS seg
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C STRICT IMMUTABLE;
 
 CREATE FUNCTION seg_out(seg)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C STRICT IMMUTABLE;
 
 CREATE TYPE seg (
 	INTERNALLENGTH = 12,
@@ -32,7 +32,7 @@ COMMENT ON TYPE seg IS
 CREATE FUNCTION seg_over_left(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_over_left(seg, seg) IS
 'overlaps or is left of';
@@ -40,7 +40,7 @@ COMMENT ON FUNCTION seg_over_left(seg, seg) IS
 CREATE FUNCTION seg_over_right(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_over_right(seg, seg) IS
 'overlaps or is right of';
@@ -48,7 +48,7 @@ COMMENT ON FUNCTION seg_over_right(seg, seg) IS
 CREATE FUNCTION seg_left(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_left(seg, seg) IS
 'is left of';
@@ -56,7 +56,7 @@ COMMENT ON FUNCTION seg_left(seg, seg) IS
 CREATE FUNCTION seg_right(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_right(seg, seg) IS
 'is right of';
@@ -67,7 +67,7 @@ COMMENT ON FUNCTION seg_right(seg, seg) IS
 CREATE FUNCTION seg_lt(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_lt(seg, seg) IS
 'less than';
@@ -75,7 +75,7 @@ COMMENT ON FUNCTION seg_lt(seg, seg) IS
 CREATE FUNCTION seg_le(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_le(seg, seg) IS
 'less than or equal';
@@ -83,7 +83,7 @@ COMMENT ON FUNCTION seg_le(seg, seg) IS
 CREATE FUNCTION seg_gt(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_gt(seg, seg) IS
 'greater than';
@@ -91,7 +91,7 @@ COMMENT ON FUNCTION seg_gt(seg, seg) IS
 CREATE FUNCTION seg_ge(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_ge(seg, seg) IS
 'greater than or equal';
@@ -99,7 +99,7 @@ COMMENT ON FUNCTION seg_ge(seg, seg) IS
 CREATE FUNCTION seg_contains(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_contains(seg, seg) IS
 'contains';
@@ -107,7 +107,7 @@ COMMENT ON FUNCTION seg_contains(seg, seg) IS
 CREATE FUNCTION seg_contained(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_contained(seg, seg) IS
 'contained in';
@@ -115,7 +115,7 @@ COMMENT ON FUNCTION seg_contained(seg, seg) IS
 CREATE FUNCTION seg_overlap(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_overlap(seg, seg) IS
 'overlaps';
@@ -123,7 +123,7 @@ COMMENT ON FUNCTION seg_overlap(seg, seg) IS
 CREATE FUNCTION seg_same(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_same(seg, seg) IS
 'same as';
@@ -131,7 +131,7 @@ COMMENT ON FUNCTION seg_same(seg, seg) IS
 CREATE FUNCTION seg_different(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_different(seg, seg) IS
 'different';
@@ -141,36 +141,36 @@ COMMENT ON FUNCTION seg_different(seg, seg) IS
 CREATE OR REPLACE FUNCTION seg_cmp(seg, seg)
 RETURNS int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_cmp(seg, seg) IS 'btree comparison function';
 
 CREATE FUNCTION seg_union(seg, seg)
 RETURNS seg
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 CREATE FUNCTION seg_inter(seg, seg)
 RETURNS seg
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 CREATE FUNCTION seg_size(seg)
 RETURNS float4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 -- miscellaneous
 
 CREATE FUNCTION seg_upper(seg)
 RETURNS float4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 CREATE FUNCTION seg_lower(seg)
 RETURNS float4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 
 --
@@ -304,37 +304,37 @@ CREATE OPERATOR ~ (
 CREATE FUNCTION gseg_consistent(internal,seg,int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gseg_compress(internal)
 RETURNS internal 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gseg_decompress(internal)
 RETURNS internal 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gseg_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE FUNCTION gseg_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gseg_union(internal, internal)
 RETURNS seg 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gseg_same(seg, seg, internal)
 RETURNS internal 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 
 -- Create the operator classes for indexing
diff --git a/contrib/spi/autoinc.sql.in b/contrib/spi/autoinc.sql.in
index 75889b3786d..a5d06240cce 100644
--- a/contrib/spi/autoinc.sql.in
+++ b/contrib/spi/autoinc.sql.in
@@ -4,4 +4,4 @@ SET search_path = public;
 CREATE OR REPLACE FUNCTION autoinc() 
 RETURNS trigger 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
diff --git a/contrib/spi/insert_username.sql.in b/contrib/spi/insert_username.sql.in
index 3d096592d29..7951188d4a4 100644
--- a/contrib/spi/insert_username.sql.in
+++ b/contrib/spi/insert_username.sql.in
@@ -4,4 +4,4 @@ SET search_path = public;
 CREATE OR REPLACE FUNCTION insert_username() 
 RETURNS trigger 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
diff --git a/contrib/spi/moddatetime.sql.in b/contrib/spi/moddatetime.sql.in
index 9bdaa9aefe0..d019cf2c9bb 100644
--- a/contrib/spi/moddatetime.sql.in
+++ b/contrib/spi/moddatetime.sql.in
@@ -4,4 +4,4 @@ SET search_path = public;
 CREATE OR REPLACE FUNCTION moddatetime()
 RETURNS trigger
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
diff --git a/contrib/spi/refint.sql.in b/contrib/spi/refint.sql.in
index 14b135e2580..661f1836e4f 100644
--- a/contrib/spi/refint.sql.in
+++ b/contrib/spi/refint.sql.in
@@ -4,9 +4,9 @@ SET search_path = public;
 CREATE OR REPLACE FUNCTION check_primary_key()
 RETURNS trigger
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE OR REPLACE FUNCTION check_foreign_key()
 RETURNS trigger
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
diff --git a/contrib/spi/timetravel.sql.in b/contrib/spi/timetravel.sql.in
index 675e2d9feb2..af17323f05a 100644
--- a/contrib/spi/timetravel.sql.in
+++ b/contrib/spi/timetravel.sql.in
@@ -1,19 +1,17 @@
 -- Adjust this setting to control where the objects get created.
 SET search_path = public;
 
-SET autocommit TO 'on';
-
 CREATE OR REPLACE FUNCTION timetravel() 
 RETURNS trigger 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE OR REPLACE FUNCTION set_timetravel(name, int4) 
 RETURNS int4 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE OR REPLACE FUNCTION get_timetravel(name) 
 RETURNS int4 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
diff --git a/contrib/tablefunc/README.tablefunc b/contrib/tablefunc/README.tablefunc
index 63b1c17d8ec..08ac4c31c17 100644
--- a/contrib/tablefunc/README.tablefunc
+++ b/contrib/tablefunc/README.tablefunc
@@ -315,7 +315,7 @@ Notes
 
       CREATE OR REPLACE FUNCTION crosstab_float8_5_cols(text)
         RETURNS setof my_crosstab_float8_5_cols
-        AS '$libdir/tablefunc','crosstab' LANGUAGE 'c' STABLE STRICT;
+        AS '$libdir/tablefunc','crosstab' LANGUAGE C STABLE STRICT;
 
       B. Use OUT parameters to define the return type implicitly.
       The same example could also be done this way:
@@ -328,7 +328,7 @@ Notes
           OUT category_4 FLOAT8,
           OUT category_5 FLOAT8)
         RETURNS setof record
-        AS '$libdir/tablefunc','crosstab' LANGUAGE 'c' STABLE STRICT;
+        AS '$libdir/tablefunc','crosstab' LANGUAGE C STABLE STRICT;
 
 
 Example usage
diff --git a/contrib/tablefunc/expected/tablefunc.out b/contrib/tablefunc/expected/tablefunc.out
index 50faf4390f1..84734ea41bb 100644
--- a/contrib/tablefunc/expected/tablefunc.out
+++ b/contrib/tablefunc/expected/tablefunc.out
@@ -128,7 +128,7 @@ CREATE FUNCTION crosstab_out(text,
 	OUT rowid text, OUT att1 text, OUT att2 text, OUT att3 text)
 RETURNS setof record
 AS '$libdir/tablefunc','crosstab'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 SELECT * FROM crosstab_out('SELECT rowid, attribute, val FROM ct where rowclass = ''group1'' ORDER BY 1,2;');
  rowid | att1 | att2 | att3 
 -------+------+------+------
@@ -231,7 +231,7 @@ create type my_crosstab_result as (
 CREATE FUNCTION crosstab_named(text, text)
 RETURNS setof my_crosstab_result
 AS '$libdir/tablefunc','crosstab_hash'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 SELECT * FROM crosstab_named(
   'SELECT rowid, rowdt, attribute, val FROM cth ORDER BY 1',
   'SELECT DISTINCT attribute FROM cth ORDER BY 1');
@@ -248,7 +248,7 @@ CREATE FUNCTION crosstab_out(text, text,
   OUT test_startdate timestamp, OUT volts float8)
 RETURNS setof record
 AS '$libdir/tablefunc','crosstab_hash'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 SELECT * FROM crosstab_out(
   'SELECT rowid, rowdt, attribute, val FROM cth ORDER BY 1',
   'SELECT DISTINCT attribute FROM cth ORDER BY 1');
diff --git a/contrib/tablefunc/sql/tablefunc.sql b/contrib/tablefunc/sql/tablefunc.sql
index 32290861330..c6054c8efc9 100644
--- a/contrib/tablefunc/sql/tablefunc.sql
+++ b/contrib/tablefunc/sql/tablefunc.sql
@@ -44,7 +44,7 @@ CREATE FUNCTION crosstab_out(text,
 	OUT rowid text, OUT att1 text, OUT att2 text, OUT att3 text)
 RETURNS setof record
 AS '$libdir/tablefunc','crosstab'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 SELECT * FROM crosstab_out('SELECT rowid, attribute, val FROM ct where rowclass = ''group1'' ORDER BY 1,2;');
 
@@ -119,7 +119,7 @@ create type my_crosstab_result as (
 CREATE FUNCTION crosstab_named(text, text)
 RETURNS setof my_crosstab_result
 AS '$libdir/tablefunc','crosstab_hash'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 SELECT * FROM crosstab_named(
   'SELECT rowid, rowdt, attribute, val FROM cth ORDER BY 1',
@@ -133,7 +133,7 @@ CREATE FUNCTION crosstab_out(text, text,
   OUT test_startdate timestamp, OUT volts float8)
 RETURNS setof record
 AS '$libdir/tablefunc','crosstab_hash'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 SELECT * FROM crosstab_out(
   'SELECT rowid, rowdt, attribute, val FROM cth ORDER BY 1',
diff --git a/contrib/tablefunc/tablefunc.sql.in b/contrib/tablefunc/tablefunc.sql.in
index fee9cb7e17b..416e23ccc79 100644
--- a/contrib/tablefunc/tablefunc.sql.in
+++ b/contrib/tablefunc/tablefunc.sql.in
@@ -4,13 +4,13 @@ SET search_path = public;
 CREATE OR REPLACE FUNCTION normal_rand(int4, float8, float8)
 RETURNS setof float8
 AS 'MODULE_PATHNAME','normal_rand'
-LANGUAGE 'C' VOLATILE STRICT;
+LANGUAGE C VOLATILE STRICT;
 
 -- the generic crosstab function:
 CREATE OR REPLACE FUNCTION crosstab(text)
 RETURNS setof record
 AS 'MODULE_PATHNAME','crosstab'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 -- examples of building custom type-specific crosstab functions:
 CREATE TYPE tablefunc_crosstab_2 AS
@@ -40,47 +40,47 @@ CREATE TYPE tablefunc_crosstab_4 AS
 CREATE OR REPLACE FUNCTION crosstab2(text)
 RETURNS setof tablefunc_crosstab_2
 AS 'MODULE_PATHNAME','crosstab'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 CREATE OR REPLACE FUNCTION crosstab3(text)
 RETURNS setof tablefunc_crosstab_3
 AS 'MODULE_PATHNAME','crosstab'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 CREATE OR REPLACE FUNCTION crosstab4(text)
 RETURNS setof tablefunc_crosstab_4
 AS 'MODULE_PATHNAME','crosstab'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 -- obsolete:
 CREATE OR REPLACE FUNCTION crosstab(text,int)
 RETURNS setof record
 AS 'MODULE_PATHNAME','crosstab'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 CREATE OR REPLACE FUNCTION crosstab(text,text)
 RETURNS setof record
 AS 'MODULE_PATHNAME','crosstab_hash'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 CREATE OR REPLACE FUNCTION connectby(text,text,text,text,int,text)
 RETURNS setof record
 AS 'MODULE_PATHNAME','connectby_text'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 CREATE OR REPLACE FUNCTION connectby(text,text,text,text,int)
 RETURNS setof record
 AS 'MODULE_PATHNAME','connectby_text'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 -- These 2 take the name of a field to ORDER BY as 4th arg (for sorting siblings)
 
 CREATE OR REPLACE FUNCTION connectby(text,text,text,text,text,int,text)
 RETURNS setof record
 AS 'MODULE_PATHNAME','connectby_text_serial'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 CREATE OR REPLACE FUNCTION connectby(text,text,text,text,text,int)
 RETURNS setof record
 AS 'MODULE_PATHNAME','connectby_text_serial'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
diff --git a/contrib/tsearch2/gendict/sql.IN b/contrib/tsearch2/gendict/sql.IN
index 044230b4173..399b26b0d9e 100644
--- a/contrib/tsearch2/gendict/sql.IN
+++ b/contrib/tsearch2/gendict/sql.IN
@@ -4,13 +4,13 @@ BEGIN;
 HASINIT create function dinit_CFG_MODNAME(internal)
 HASINIT         returns internal
 HASINIT         as 'MODULE_PATHNAME'
-HASINIT         language 'C';
+HASINIT         language C;
 
 NOSNOWBALL create function dlexize_CFG_MODNAME(internal,internal,int4)
 NOSNOWBALL        returns internal
 NOSNOWBALL        as 'MODULE_PATHNAME'
-NOSNOWBALL        language 'C'
-NOSNOWBALL        with (isstrict);
+NOSNOWBALL        language C
+NOSNOWBALL        returns null on null input;
 
 insert into pg_ts_dict select
         'CFG_MODNAME',
diff --git a/contrib/tsearch2/tsearch.sql.in b/contrib/tsearch2/tsearch.sql.in
index 07290838fff..c30a80e51ff 100644
--- a/contrib/tsearch2/tsearch.sql.in
+++ b/contrib/tsearch2/tsearch.sql.in
@@ -14,46 +14,46 @@ CREATE TABLE pg_ts_dict (
 
 --dict interface
 CREATE FUNCTION lexize(oid, text) 
-	returns _text
+	RETURNS _text
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION lexize(text, text)
-        returns _text
+        RETURNS _text
         as 'MODULE_PATHNAME', 'lexize_byname'
-        language 'C'
-        with (isstrict);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION lexize(text)
-        returns _text
+        RETURNS _text
         as 'MODULE_PATHNAME', 'lexize_bycurrent'
-        language 'C'
-        with (isstrict);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION set_curdict(int)
-	returns void
+	RETURNS void
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION set_curdict(text)
-	returns void
+	RETURNS void
 	as 'MODULE_PATHNAME', 'set_curdict_byname'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 --built-in dictionaries
 CREATE FUNCTION dex_init(internal)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME' 
-	language 'C';
+	LANGUAGE C;
 
 CREATE FUNCTION dex_lexize(internal,internal,int4)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 insert into pg_ts_dict select 
 	'simple', 
@@ -64,15 +64,15 @@ insert into pg_ts_dict select
 ;
 	 
 CREATE FUNCTION snb_en_init(internal)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME' 
-	language 'C';
+	LANGUAGE C;
 
 CREATE FUNCTION snb_lexize(internal,internal,int4)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 insert into pg_ts_dict select 
 	'en_stem', 
@@ -83,9 +83,9 @@ insert into pg_ts_dict select
 ;
 
 CREATE FUNCTION snb_ru_init_koi8(internal)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME' 
-	language 'C';
+	LANGUAGE C;
 
 insert into pg_ts_dict select 
 	'ru_stem_koi8', 
@@ -96,9 +96,9 @@ insert into pg_ts_dict select
 ;
 	 
 CREATE FUNCTION snb_ru_init_utf8(internal)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME' 
-	language 'C';
+	LANGUAGE C;
 
 insert into pg_ts_dict select 
 	'ru_stem_utf8', 
@@ -109,15 +109,15 @@ insert into pg_ts_dict select
 ;
 	 
 CREATE FUNCTION spell_init(internal)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME' 
-	language 'C';
+	LANGUAGE C;
 
 CREATE FUNCTION spell_lexize(internal,internal,int4)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 insert into pg_ts_dict select 
 	'ispell_template', 
@@ -128,15 +128,15 @@ insert into pg_ts_dict select
 ;
 
 CREATE FUNCTION syn_init(internal)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME' 
-	language 'C';
+	LANGUAGE C;
 
 CREATE FUNCTION syn_lexize(internal,internal,int4)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 insert into pg_ts_dict select 
 	'synonym', 
@@ -162,81 +162,81 @@ CREATE TYPE tokentype
 	as (tokid int4, alias text, descr text); 
 
 CREATE FUNCTION token_type(int4)
-	returns setof tokentype
+	RETURNS setof tokentype
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION token_type(text)
-	returns setof tokentype
+	RETURNS setof tokentype
 	as 'MODULE_PATHNAME', 'token_type_byname'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION token_type()
-	returns setof tokentype
+	RETURNS setof tokentype
 	as 'MODULE_PATHNAME', 'token_type_current'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION set_curprs(int)
-	returns void
+	RETURNS void
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION set_curprs(text)
-	returns void
+	RETURNS void
 	as 'MODULE_PATHNAME', 'set_curprs_byname'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE tokenout 
 	as (tokid int4, token text);
 
 CREATE FUNCTION parse(oid,text)
-	returns setof tokenout
+	RETURNS setof tokenout
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
  
 CREATE FUNCTION parse(text,text)
-	returns setof tokenout
+	RETURNS setof tokenout
 	as 'MODULE_PATHNAME', 'parse_byname'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
  
 CREATE FUNCTION parse(text)
-	returns setof tokenout
+	RETURNS setof tokenout
 	as 'MODULE_PATHNAME', 'parse_current'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
  
 --default parser
 CREATE FUNCTION prsd_start(internal,int4)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME'
-	language 'C';
+	LANGUAGE C;
 
 CREATE FUNCTION prsd_getlexeme(internal,internal,internal)
-	returns int4
+	RETURNS int4
 	as 'MODULE_PATHNAME'
-	language 'C';
+	LANGUAGE C;
 
 CREATE FUNCTION prsd_end(internal)
-	returns void
+	RETURNS void
 	as 'MODULE_PATHNAME'
-	language 'C';
+	LANGUAGE C;
 
 CREATE FUNCTION prsd_lextype(internal)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME'
-	language 'C';
+	LANGUAGE C;
 
 CREATE FUNCTION prsd_headline(internal,internal,internal)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME'
-	language 'C';
+	LANGUAGE C;
 
 insert into pg_ts_parser select
 	'default',
@@ -264,22 +264,22 @@ CREATE TABLE pg_ts_cfgmap (
 ) with oids;
 
 CREATE FUNCTION set_curcfg(int)
-	returns void
+	RETURNS void
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION set_curcfg(text)
-	returns void
+	RETURNS void
 	as 'MODULE_PATHNAME', 'set_curcfg_byname'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION show_curcfg()
-	returns oid
+	RETURNS oid
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 insert into pg_ts_cfg values ('default', 'default','C');
 insert into pg_ts_cfg values ('default_russian', 'default','ru_RU.KOI8-R');
@@ -367,12 +367,12 @@ insert into pg_ts_cfgmap values ('simple', 'uint', '{simple}');
 CREATE FUNCTION tsvector_in(cstring)
 RETURNS tsvector
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION tsvector_out(tsvector)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE tsvector (
         INTERNALLENGTH = -1,
@@ -384,37 +384,37 @@ CREATE TYPE tsvector (
 CREATE FUNCTION length(tsvector)
 RETURNS int4
 AS 'MODULE_PATHNAME', 'tsvector_length'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION to_tsvector(oid, text)
 RETURNS tsvector
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION to_tsvector(text, text)
 RETURNS tsvector
 AS 'MODULE_PATHNAME', 'to_tsvector_name'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION to_tsvector(text)
 RETURNS tsvector
 AS 'MODULE_PATHNAME', 'to_tsvector_current'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION strip(tsvector)
 RETURNS tsvector
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION setweight(tsvector,"char")
 RETURNS tsvector
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION concat(tsvector,tsvector)
 RETURNS tsvector
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR || (
         LEFTARG = tsvector,
@@ -426,12 +426,12 @@ CREATE OPERATOR || (
 CREATE FUNCTION tsquery_in(cstring)
 RETURNS tsquery
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION tsquery_out(tsquery)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE tsquery (
         INTERNALLENGTH = -1,
@@ -443,50 +443,50 @@ CREATE TYPE tsquery (
 CREATE FUNCTION querytree(tsquery)
 RETURNS text
 AS 'MODULE_PATHNAME', 'tsquerytree'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION to_tsquery(oid, text)
 RETURNS tsquery
 AS 'MODULE_PATHNAME'
-LANGUAGE 'c' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION to_tsquery(text, text)
 RETURNS tsquery
 AS 'MODULE_PATHNAME','to_tsquery_name'
-LANGUAGE 'c' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION to_tsquery(text)
 RETURNS tsquery
 AS 'MODULE_PATHNAME','to_tsquery_current'
-LANGUAGE 'c' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION plainto_tsquery(oid, text)
 RETURNS tsquery
 AS 'MODULE_PATHNAME'
-LANGUAGE 'c' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION plainto_tsquery(text, text)
 RETURNS tsquery
 AS 'MODULE_PATHNAME','plainto_tsquery_name'
-LANGUAGE 'c' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION plainto_tsquery(text)
 RETURNS tsquery
 AS 'MODULE_PATHNAME','plainto_tsquery_current'
-LANGUAGE 'c' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 --operations
 CREATE FUNCTION exectsq(tsvector, tsquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
   
 COMMENT ON FUNCTION exectsq(tsvector, tsquery) IS 'boolean operation with text index';
 
 CREATE FUNCTION rexectsq(tsquery, tsvector)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 COMMENT ON FUNCTION rexectsq(tsquery, tsvector) IS 'boolean operation with text index';
 
@@ -511,90 +511,90 @@ CREATE OPERATOR @@ (
 CREATE FUNCTION tsearch2()
 RETURNS trigger
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 --Relevation
 CREATE FUNCTION rank(float4[], tsvector, tsquery)
 RETURNS float4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION rank(float4[], tsvector, tsquery, int4)
 RETURNS float4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION rank(tsvector, tsquery)
 RETURNS float4
 AS 'MODULE_PATHNAME', 'rank_def'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION rank(tsvector, tsquery, int4)
 RETURNS float4
 AS 'MODULE_PATHNAME', 'rank_def'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION rank_cd(int4, tsvector, tsquery)
 RETURNS float4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION rank_cd(int4, tsvector, tsquery, int4)
 RETURNS float4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION rank_cd(tsvector, tsquery)
 RETURNS float4
 AS 'MODULE_PATHNAME', 'rank_cd_def'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION rank_cd(tsvector, tsquery, int4)
 RETURNS float4
 AS 'MODULE_PATHNAME', 'rank_cd_def'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION headline(oid, text, tsquery, text)
 RETURNS text
 AS 'MODULE_PATHNAME', 'headline'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION headline(oid, text, tsquery)
 RETURNS text
 AS 'MODULE_PATHNAME', 'headline'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION headline(text, text, tsquery, text)
 RETURNS text
 AS 'MODULE_PATHNAME', 'headline_byname'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION headline(text, text, tsquery)
 RETURNS text
 AS 'MODULE_PATHNAME', 'headline_byname'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION headline(text, tsquery, text)
 RETURNS text
 AS 'MODULE_PATHNAME', 'headline_current'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION headline(text, tsquery)
 RETURNS text
 AS 'MODULE_PATHNAME', 'headline_current'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 --GiST
 --GiST key type 
 CREATE FUNCTION gtsvector_in(cstring)
 RETURNS gtsvector
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gtsvector_out(gtsvector)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE gtsvector (
         INTERNALLENGTH = -1,
@@ -606,37 +606,37 @@ CREATE TYPE gtsvector (
 CREATE FUNCTION gtsvector_consistent(gtsvector,internal,int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
   
 CREATE FUNCTION gtsvector_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtsvector_decompress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtsvector_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gtsvector_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtsvector_union(internal, internal)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtsvector_same(gtsvector, gtsvector, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- CREATE the OPERATOR class
 CREATE OPERATOR CLASS gist_tsvector_ops
@@ -660,12 +660,12 @@ CREATE TYPE statinfo
 --CREATE FUNCTION tsstat_in(cstring)
 --RETURNS tsstat
 --AS 'MODULE_PATHNAME'
---LANGUAGE 'C' with (isstrict);
+--LANGUAGE C RETURNS NULL ON NULL INPUT;
 --
 --CREATE FUNCTION tsstat_out(tsstat)
 --RETURNS cstring
 --AS 'MODULE_PATHNAME'
---LANGUAGE 'C' with (isstrict);
+--LANGUAGE C RETURNS NULL ON NULL INPUT;
 --
 --CREATE TYPE tsstat (
 --        INTERNALLENGTH = -1,
@@ -677,13 +677,13 @@ CREATE TYPE statinfo
 --CREATE FUNCTION ts_accum(tsstat,tsvector)
 --RETURNS tsstat
 --AS 'MODULE_PATHNAME'
---LANGUAGE 'C' with (isstrict);
+--LANGUAGE C RETURNS NULL ON NULL INPUT;
 --
 --CREATE FUNCTION ts_accum_finish(tsstat)
---	returns setof statinfo
+--	RETURNS setof statinfo
 --	as 'MODULE_PATHNAME'
---	language 'C'
---	with (isstrict);
+--	LANGUAGE C
+--	RETURNS NULL ON NULL INPUT;
 --
 --CREATE AGGREGATE stat (
 --	BASETYPE=tsvector,
@@ -694,30 +694,30 @@ CREATE TYPE statinfo
 --); 
 
 CREATE FUNCTION stat(text)
-	returns setof statinfo
+	RETURNS setof statinfo
 	as 'MODULE_PATHNAME', 'ts_stat'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION stat(text,text)
-	returns setof statinfo
+	RETURNS setof statinfo
 	as 'MODULE_PATHNAME', 'ts_stat'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 --reset - just for debuging
 CREATE FUNCTION reset_tsearch()
-        returns void
+        RETURNS void
         as 'MODULE_PATHNAME'
-        language 'C'
-        with (isstrict);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT;
 
 --get cover (debug for rank_cd)
 CREATE FUNCTION get_covers(tsvector,tsquery)
-        returns text
+        RETURNS text
         as 'MODULE_PATHNAME'
-        language 'C'
-        with (isstrict);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT;
 
 --debug function
 create type tsdebug as (
@@ -729,13 +729,13 @@ create type tsdebug as (
         "tsvector" tsvector
 );
 
-create function _get_parser_from_curcfg() 
-returns text as 
+CREATE FUNCTION _get_parser_from_curcfg() 
+RETURNS text as 
 ' select prs_name from pg_ts_cfg where oid = show_curcfg() '
-language 'SQL' with(isstrict,iscachable);
+LANGUAGE SQL RETURNS NULL ON NULL INPUT IMMUTABLE;
 
-create function ts_debug(text)
-returns setof tsdebug as '
+CREATE FUNCTION ts_debug(text)
+RETURNS setof tsdebug as '
 select 
         m.ts_name,
         t.alias as tok_type,
@@ -753,43 +753,43 @@ where
         t.alias = m.tok_alias and 
         m.ts_name=c.ts_name and 
         c.oid=show_curcfg() 
-' language 'SQL' with(isstrict);
+' LANGUAGE SQL RETURNS NULL ON NULL INPUT;
 
 --compare functions
 CREATE FUNCTION tsvector_cmp(tsvector,tsvector)
 RETURNS int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION tsvector_lt(tsvector,tsvector)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION tsvector_le(tsvector,tsvector)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
         
 CREATE FUNCTION tsvector_eq(tsvector,tsvector)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION tsvector_ge(tsvector,tsvector)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
         
 CREATE FUNCTION tsvector_gt(tsvector,tsvector)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION tsvector_ne(tsvector,tsvector)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR < (
         LEFTARG = tsvector,
@@ -866,37 +866,37 @@ CREATE OPERATOR CLASS tsvector_ops
 CREATE OR REPLACE FUNCTION tsquery_cmp(tsquery,tsquery)
 RETURNS int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION tsquery_lt(tsquery,tsquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION tsquery_le(tsquery,tsquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION tsquery_eq(tsquery,tsquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION tsquery_ge(tsquery,tsquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION tsquery_gt(tsquery,tsquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION tsquery_ne(tsquery,tsquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 
 CREATE OPERATOR < (
@@ -972,16 +972,16 @@ CREATE OPERATOR CLASS tsquery_ops
         FUNCTION        1       tsquery_cmp(tsquery, tsquery);
 
 CREATE OR REPLACE FUNCTION numnode(tsquery)
-        returns int4
+        RETURNS int4
         as 'MODULE_PATHNAME', 'tsquery_numnode'
-        language 'C'
-        with (isstrict,iscachable);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION tsquery_and(tsquery,tsquery)
-        returns tsquery
+        RETURNS tsquery
         as 'MODULE_PATHNAME', 'tsquery_and'
-        language 'C'
-        with (isstrict,iscachable);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR && (
         LEFTARG = tsquery,
@@ -993,10 +993,10 @@ CREATE OPERATOR && (
 );
 
 CREATE OR REPLACE FUNCTION tsquery_or(tsquery,tsquery)
-        returns tsquery
+        RETURNS tsquery
         as 'MODULE_PATHNAME', 'tsquery_or'
-        language 'C'
-        with (isstrict,iscachable);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR || (
         LEFTARG = tsquery,
@@ -1008,10 +1008,10 @@ CREATE OPERATOR || (
 );
 
 CREATE OR REPLACE FUNCTION tsquery_not(tsquery)
-        returns tsquery
+        RETURNS tsquery
         as 'MODULE_PATHNAME', 'tsquery_not'
-        language 'C'
-        with (isstrict,iscachable);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR !! (
         RIGHTARG = tsquery,
@@ -1021,26 +1021,26 @@ CREATE OPERATOR !! (
 --------------rewrite subsystem
 
 CREATE OR REPLACE FUNCTION rewrite(tsquery, text)
-        returns tsquery
+        RETURNS tsquery
         as 'MODULE_PATHNAME', 'tsquery_rewrite'
-        language 'C'
-        with (isstrict,iscachable);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION rewrite(tsquery, tsquery, tsquery)
-        returns tsquery
+        RETURNS tsquery
         as 'MODULE_PATHNAME', 'tsquery_rewrite_query'
-        language 'C'
-        with (isstrict,iscachable);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION rewrite_accum(tsquery,tsquery[])
         RETURNS tsquery
         AS 'MODULE_PATHNAME'
-        LANGUAGE 'C';
+        LANGUAGE C;
 
 CREATE OR REPLACE FUNCTION rewrite_finish(tsquery)
-      returns tsquery
+      RETURNS tsquery
       as 'MODULE_PATHNAME'
-      language 'C';
+      LANGUAGE C;
 
 CREATE AGGREGATE rewrite (
       BASETYPE=tsquery[],
@@ -1050,16 +1050,16 @@ CREATE AGGREGATE rewrite (
 );
 
 CREATE OR REPLACE FUNCTION tsq_mcontains(tsquery, tsquery)
-        returns bool
+        RETURNS bool
         as 'MODULE_PATHNAME'
-        language 'C'
-        with (isstrict,iscachable);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION tsq_mcontained(tsquery, tsquery)
-        returns bool
+        RETURNS bool
         as 'MODULE_PATHNAME'
-        language 'C'
-        with (isstrict,iscachable);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR @ (
         LEFTARG = tsquery,
@@ -1084,12 +1084,12 @@ CREATE OPERATOR ~ (
 CREATE FUNCTION gtsq_in(cstring)
 RETURNS gtsq
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gtsq_out(gtsq)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE gtsq (
         INTERNALLENGTH = 8,
@@ -1100,37 +1100,37 @@ CREATE TYPE gtsq (
 CREATE FUNCTION gtsq_consistent(gtsq,internal,int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtsq_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtsq_decompress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtsq_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gtsq_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtsq_union(bytea, internal)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtsq_same(gtsq, gtsq, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE OPERATOR CLASS gist_tp_tsquery_ops
 DEFAULT FOR TYPE tsquery USING gist
diff --git a/contrib/xml2/pgxml.sql.in b/contrib/xml2/pgxml.sql.in
index 27bcf527572..006f3f7f53c 100644
--- a/contrib/xml2/pgxml.sql.in
+++ b/contrib/xml2/pgxml.sql.in
@@ -1,32 +1,32 @@
 --SQL for XML parser
 
 CREATE OR REPLACE FUNCTION xml_valid(text) RETURNS bool
-	AS 'MODULE_PATHNAME' LANGUAGE 'c' STRICT IMMUTABLE;
+	AS 'MODULE_PATHNAME' LANGUAGE C STRICT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION xml_encode_special_chars(text) RETURNS text
-	AS 'MODULE_PATHNAME' LANGUAGE 'c' STRICT IMMUTABLE;
+	AS 'MODULE_PATHNAME' LANGUAGE C STRICT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION xpath_string(text,text) RETURNS text
-	AS 'MODULE_PATHNAME' LANGUAGE 'c' STRICT IMMUTABLE;
+	AS 'MODULE_PATHNAME' LANGUAGE C STRICT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION xpath_nodeset(text,text,text,text) RETURNS text
-	AS 'MODULE_PATHNAME' LANGUAGE 'c' STRICT IMMUTABLE;
+	AS 'MODULE_PATHNAME' LANGUAGE C STRICT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION xpath_number(text,text) RETURNS float4
-	AS 'MODULE_PATHNAME' LANGUAGE 'c' STRICT IMMUTABLE;
+	AS 'MODULE_PATHNAME' LANGUAGE C STRICT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION xpath_bool(text,text) RETURNS boolean
-	AS 'MODULE_PATHNAME' LANGUAGE 'c' STRICT IMMUTABLE;
+	AS 'MODULE_PATHNAME' LANGUAGE C STRICT IMMUTABLE;
 
 -- List function
 
 CREATE OR REPLACE FUNCTION xpath_list(text,text,text) RETURNS text
 	AS 'MODULE_PATHNAME'
-	LANGUAGE 'c' STRICT IMMUTABLE;
+	LANGUAGE C STRICT IMMUTABLE;
 
 
 CREATE OR REPLACE FUNCTION xpath_list(text,text) RETURNS text 
-AS 'SELECT xpath_list($1,$2,'','')' language 'SQL' STRICT IMMUTABLE;
+AS 'SELECT xpath_list($1,$2,'','')' LANGUAGE SQL STRICT IMMUTABLE;
 
 
 
@@ -34,17 +34,17 @@ AS 'SELECT xpath_list($1,$2,'','')' language 'SQL' STRICT IMMUTABLE;
 
 
 CREATE OR REPLACE FUNCTION xpath_nodeset(text,text) RETURNS text AS
-'SELECT xpath_nodeset($1,$2,'''','''')' language 'SQL' STRICT IMMUTABLE;
+'SELECT xpath_nodeset($1,$2,'''','''')' LANGUAGE SQL STRICT IMMUTABLE;
 
 
 CREATE OR REPLACE FUNCTION xpath_nodeset(text,text,text) RETURNS text AS
-'SELECT xpath_nodeset($1,$2,'''',$3)' language 'SQL' STRICT IMMUTABLE;
+'SELECT xpath_nodeset($1,$2,'''',$3)' LANGUAGE SQL STRICT IMMUTABLE;
 
 -- Table function
 
 CREATE OR REPLACE FUNCTION xpath_table(text,text,text,text,text) RETURNS setof record
 	AS 'MODULE_PATHNAME'
-	LANGUAGE 'c' STRICT STABLE;
+	LANGUAGE C STRICT STABLE;
 
 -- XSLT functions
 -- Delete from here to the end of the file if you are not compiling with
@@ -52,9 +52,9 @@ CREATE OR REPLACE FUNCTION xpath_table(text,text,text,text,text) RETURNS setof r
 
 
 CREATE OR REPLACE FUNCTION xslt_process(text,text,text) RETURNS text 
-	AS 'MODULE_PATHNAME' LANGUAGE 'c' STRICT VOLATILE;
+	AS 'MODULE_PATHNAME' LANGUAGE C STRICT VOLATILE;
 
 -- the function checks for the correct argument count
 
 CREATE OR REPLACE FUNCTION xslt_process(text,text) RETURNS text 
-	AS 'MODULE_PATHNAME' LANGUAGE 'c' STRICT IMMUTABLE;
+	AS 'MODULE_PATHNAME' LANGUAGE C STRICT IMMUTABLE;
-- 
cgit v1.2.3