Clean up CREATE FUNCTION syntax usage in contrib and elsewhere, in

particular get rid of single quotes around language names and old WITH ()
construct.

36 files changed, 732 insertions, 741 deletions

diff --git a/contrib/btree_gist/btree_gist.sql.in b/contrib/btree_gist/btree_gist.sql.in
index e91cf1924b..3cad635444 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 ff920d1f59..7b521abf15 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 c38f8be888..7cd705ba54 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 18c5b0693e..d4e378998a 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 b5de753443..3811b1d77f 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 2425288b83..c2a24096c3 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 a3ac6da586..9e120dc892 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 17f000149b..4feb51964f 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 93eff0f633..c060ee8757 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 5a58655cdc..cb33c64469 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 f0b35b2181..b9d33a7a43 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 0094bdcd60..85c8d8bb14 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 740296cdf7..1fb0b5ffb4 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 55b15d0f82..a9d722d051 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 e80c391ab0..8e7d5680a8 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 56d81c20d3..ec1edcfa17 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 1dd0b2eae6..85c7b2869a 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 a185186518..26574ea1c0 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 f38abb6e48..6ee16f6e23 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 fb3949d56e..a6ff645c4f 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 3e7facb80f..7395b1ce31 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 40bfa8d3ac..1c3c982b28 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		-- ºÆÍøÍѲÄǽ¤ÊÎΰ补table_len¤ËÂФ¹¤ëfree_space¤ÎÈæΨ¡¥
 
    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 f7eac5040f..440b978682 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 ca30a30ba5..94a02224a0 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 75889b3786..a5d06240cc 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 3d096592d2..7951188d4a 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 9bdaa9aefe..d019cf2c9b 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 14b135e258..661f1836e4 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 675e2d9feb..af17323f05 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 63b1c17d8e..08ac4c31c1 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 50faf4390f..84734ea41b 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 3229086133..c6054c8efc 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 fee9cb7e17..416e23ccc7 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 044230b417..399b26b0d9 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 07290838ff..c30a80e51f 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 27bcf52757..006f3f7f53 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;