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

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

65 files changed, 967 insertions, 976 deletions

diff --git a/contrib/btree_gist/btree_gist.sql.in b/contrib/btree_gist/btree_gist.sql.in
index e91cf1924b4..3cad6354442 100644
--- a/contrib/btree_gist/btree_gist.sql.in
+++ b/contrib/btree_gist/btree_gist.sql.in
@@ -4,12 +4,12 @@ SET search_path = public;
 CREATE FUNCTION gbtreekey4_in(cstring)
 RETURNS gbtreekey4
 AS 'MODULE_PATHNAME', 'gbtreekey_in'
-LANGUAGE 'c' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbtreekey4_out(gbtreekey4)
 RETURNS cstring
 AS 'MODULE_PATHNAME', 'gbtreekey_out'
-LANGUAGE 'c' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE gbtreekey4 (
 INTERNALLENGTH = 4,
@@ -20,12 +20,12 @@ OUTPUT = gbtreekey4_out
 CREATE FUNCTION gbtreekey8_in(cstring)
 RETURNS gbtreekey8
 AS 'MODULE_PATHNAME', 'gbtreekey_in'
-LANGUAGE 'c' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbtreekey8_out(gbtreekey8)
 RETURNS cstring
 AS 'MODULE_PATHNAME', 'gbtreekey_out'
-LANGUAGE 'c' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE gbtreekey8 (
 INTERNALLENGTH = 8,
@@ -36,12 +36,12 @@ OUTPUT = gbtreekey8_out
 CREATE FUNCTION gbtreekey16_in(cstring)
 RETURNS gbtreekey16
 AS 'MODULE_PATHNAME', 'gbtreekey_in'
-LANGUAGE 'c' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbtreekey16_out(gbtreekey16)
 RETURNS cstring
 AS 'MODULE_PATHNAME', 'gbtreekey_out'
-LANGUAGE 'c' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE gbtreekey16 (
 INTERNALLENGTH = 16,
@@ -52,12 +52,12 @@ OUTPUT = gbtreekey16_out
 CREATE FUNCTION gbtreekey32_in(cstring)
 RETURNS gbtreekey32
 AS 'MODULE_PATHNAME', 'gbtreekey_in'
-LANGUAGE 'c' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbtreekey32_out(gbtreekey32)
 RETURNS cstring
 AS 'MODULE_PATHNAME', 'gbtreekey_out'
-LANGUAGE 'c' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE gbtreekey32 (
 INTERNALLENGTH = 32,
@@ -68,12 +68,12 @@ OUTPUT = gbtreekey32_out
 CREATE FUNCTION gbtreekey_var_in(cstring)
 RETURNS gbtreekey_var
 AS 'MODULE_PATHNAME', 'gbtreekey_in'
-LANGUAGE 'c' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbtreekey_var_out(gbtreekey_var)
 RETURNS cstring
 AS 'MODULE_PATHNAME', 'gbtreekey_out'
-LANGUAGE 'c' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE gbtreekey_var (
 INTERNALLENGTH = VARIABLE,
@@ -95,42 +95,42 @@ STORAGE = EXTENDED
 CREATE FUNCTION gbt_oid_consistent(internal,oid,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_oid_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_decompress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_var_decompress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_oid_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_oid_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_oid_union(bytea, internal)
 RETURNS gbtreekey8
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_oid_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_oid_ops
@@ -162,32 +162,32 @@ AS
 CREATE FUNCTION gbt_int2_consistent(internal,int2,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int2_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int2_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_int2_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int2_union(bytea, internal)
 RETURNS gbtreekey4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int2_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_int2_ops
@@ -218,32 +218,32 @@ AS
 CREATE FUNCTION gbt_int4_consistent(internal,int4,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int4_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int4_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_int4_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int4_union(bytea, internal)
 RETURNS gbtreekey8
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int4_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_int4_ops
@@ -274,32 +274,32 @@ AS
 CREATE FUNCTION gbt_int8_consistent(internal,int8,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int8_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int8_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_int8_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int8_union(bytea, internal)
 RETURNS gbtreekey16
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_int8_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_int8_ops
@@ -331,32 +331,32 @@ AS
 CREATE FUNCTION gbt_float4_consistent(internal,float4,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_float4_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_float4_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_float4_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_float4_union(bytea, internal)
 RETURNS gbtreekey8
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_float4_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_float4_ops
@@ -390,32 +390,32 @@ AS
 CREATE FUNCTION gbt_float8_consistent(internal,float8,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_float8_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_float8_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_float8_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_float8_union(bytea, internal)
 RETURNS gbtreekey16
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_float8_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_float8_ops
@@ -447,42 +447,42 @@ AS
 CREATE FUNCTION gbt_ts_consistent(internal,timestamp,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_tstz_consistent(internal,timestamptz,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
       
 CREATE FUNCTION gbt_ts_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_tstz_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_ts_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
    
 CREATE FUNCTION gbt_ts_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
       
 CREATE FUNCTION gbt_ts_union(bytea, internal)
 RETURNS gbtreekey16
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_ts_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_timestamp_ops
@@ -533,42 +533,42 @@ AS
 CREATE FUNCTION gbt_time_consistent(internal,time,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_timetz_consistent(internal,timetz,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_time_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_timetz_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_time_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
    
 CREATE FUNCTION gbt_time_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
       
 CREATE FUNCTION gbt_time_union(bytea, internal)
 RETURNS gbtreekey16
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_time_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_time_ops
@@ -617,32 +617,32 @@ AS
 CREATE FUNCTION gbt_date_consistent(internal,date,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_date_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_date_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
    
 CREATE FUNCTION gbt_date_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
       
 CREATE FUNCTION gbt_date_union(bytea, internal)
 RETURNS gbtreekey8
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_date_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_date_ops
@@ -674,37 +674,37 @@ AS
 CREATE FUNCTION gbt_intv_consistent(internal,interval,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_intv_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_intv_decompress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_intv_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
    
 CREATE FUNCTION gbt_intv_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
       
 CREATE FUNCTION gbt_intv_union(bytea, internal)
 RETURNS gbtreekey32
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_intv_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_interval_ops
@@ -735,32 +735,32 @@ AS
 CREATE FUNCTION gbt_cash_consistent(internal,money,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_cash_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_cash_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_cash_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_cash_union(bytea, internal)
 RETURNS gbtreekey8
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_cash_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_cash_ops
@@ -791,32 +791,32 @@ AS
 CREATE FUNCTION gbt_macad_consistent(internal,macaddr,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_macad_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_macad_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_macad_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_macad_union(bytea, internal)
 RETURNS gbtreekey16
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_macad_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_macaddr_ops
@@ -849,42 +849,42 @@ AS
 CREATE FUNCTION gbt_text_consistent(internal,text,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_bpchar_consistent(internal,bpchar,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_text_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_bpchar_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_text_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_text_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_text_union(bytea, internal)
 RETURNS gbtreekey_var
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_text_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_text_ops
@@ -935,32 +935,32 @@ AS
 CREATE FUNCTION gbt_bytea_consistent(internal,bytea,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_bytea_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_bytea_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_bytea_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_bytea_union(bytea, internal)
 RETURNS gbtreekey_var
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_bytea_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_bytea_ops
@@ -992,32 +992,32 @@ AS
 CREATE FUNCTION gbt_numeric_consistent(internal,numeric,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_numeric_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_numeric_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_numeric_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_numeric_union(bytea, internal)
 RETURNS gbtreekey_var
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_numeric_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_numeric_ops
@@ -1047,32 +1047,32 @@ AS
 CREATE FUNCTION gbt_bit_consistent(internal,bit,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_bit_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_bit_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_bit_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_bit_union(bytea, internal)
 RETURNS gbtreekey_var
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_bit_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_bit_ops
@@ -1124,32 +1124,32 @@ AS
 CREATE FUNCTION gbt_inet_consistent(internal,inet,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_inet_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_inet_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gbt_inet_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_inet_union(bytea, internal)
 RETURNS gbtreekey16
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gbt_inet_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create the operator class
 CREATE OPERATOR CLASS gist_inet_ops
diff --git a/contrib/cube/cube.sql.in b/contrib/cube/cube.sql.in
index ff920d1f596..7b521abf156 100644
--- a/contrib/cube/cube.sql.in
+++ b/contrib/cube/cube.sql.in
@@ -7,12 +7,12 @@ SET search_path = public;
 CREATE OR REPLACE FUNCTION cube_in(cstring)
 RETURNS cube
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION cube_out(cube)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE TYPE cube (
 	INTERNALLENGTH = variable,
@@ -27,7 +27,7 @@ COMMENT ON TYPE cube IS 'multi-dimensional cube ''(FLOAT-1, FLOAT-2, ..., FLOAT-
 
 CREATE OR REPLACE FUNCTION cube(text) RETURNS cube
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube(text) IS 'convert text to cube';
 
@@ -42,70 +42,70 @@ CREATE CAST (text AS cube) WITH FUNCTION cube(text) AS ASSIGNMENT;
 CREATE OR REPLACE FUNCTION cube_eq(cube, cube)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube_eq(cube, cube) IS 'same as';
 
 CREATE OR REPLACE FUNCTION cube_ne(cube, cube)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube_ne(cube, cube) IS 'different';
 
 CREATE OR REPLACE FUNCTION cube_lt(cube, cube)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube_lt(cube, cube) IS 'lower than';
 
 CREATE OR REPLACE FUNCTION cube_gt(cube, cube)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube_gt(cube, cube) IS 'greater than';
 
 CREATE OR REPLACE FUNCTION cube_le(cube, cube)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube_le(cube, cube) IS 'lower than or equal to';
 
 CREATE OR REPLACE FUNCTION cube_ge(cube, cube)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube_ge(cube, cube) IS 'greater than or equal to';
 
 CREATE OR REPLACE FUNCTION cube_cmp(cube, cube)
 RETURNS int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube_cmp(cube, cube) IS 'btree comparison function';
 
 CREATE OR REPLACE FUNCTION cube_contains(cube, cube)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube_contains(cube, cube) IS 'contains';
 
 CREATE OR REPLACE FUNCTION cube_contained(cube, cube)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube_contained(cube, cube) IS 'contained in';
 
 CREATE OR REPLACE FUNCTION cube_overlap(cube, cube)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 COMMENT ON FUNCTION cube_overlap(cube, cube) IS 'overlaps';
 
@@ -114,17 +114,17 @@ COMMENT ON FUNCTION cube_overlap(cube, cube) IS 'overlaps';
 CREATE OR REPLACE FUNCTION cube_union(cube, cube)
 RETURNS cube
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION cube_inter(cube, cube)
 RETURNS cube
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION cube_size(cube)
 RETURNS float8
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 
 -- Misc N-dimensional functions
@@ -134,54 +134,54 @@ LANGUAGE 'C' IMMUTABLE STRICT;
 CREATE OR REPLACE FUNCTION cube_distance(cube, cube)
 RETURNS float8
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 -- Extracting elements functions
 
 CREATE OR REPLACE FUNCTION cube_dim(cube)
 RETURNS int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION cube_ll_coord(cube, int4)
 RETURNS float8
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION cube_ur_coord(cube, int4)
 RETURNS float8
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION cube(float8) RETURNS cube
 AS 'MODULE_PATHNAME', 'cube_f8'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION cube(float8, float8) RETURNS cube
 AS 'MODULE_PATHNAME', 'cube_f8_f8'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION cube(cube, float8) RETURNS cube
 AS 'MODULE_PATHNAME', 'cube_c_f8'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION cube(cube, float8, float8) RETURNS cube
 AS 'MODULE_PATHNAME', 'cube_c_f8_f8'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 -- Test if cube is also a point
 
 CREATE OR REPLACE FUNCTION cube_is_point(cube)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 -- Increasing the size of a cube by a radius in at least n dimensions
 
 CREATE OR REPLACE FUNCTION cube_enlarge(cube, float8, int4)
 RETURNS cube
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 --
 -- OPERATORS
@@ -247,37 +247,37 @@ CREATE OPERATOR ~ (
 CREATE OR REPLACE FUNCTION g_cube_consistent(internal,cube,int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE OR REPLACE FUNCTION g_cube_compress(internal)
 RETURNS internal 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE OR REPLACE FUNCTION g_cube_decompress(internal)
 RETURNS internal 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE OR REPLACE FUNCTION g_cube_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION g_cube_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE OR REPLACE FUNCTION g_cube_union(internal, internal)
 RETURNS cube 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE OR REPLACE FUNCTION g_cube_same(cube, cube, internal)
 RETURNS internal 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 
 -- Create the operator classes for indexing
diff --git a/contrib/dblink/dblink.sql.in b/contrib/dblink/dblink.sql.in
index c38f8be8882..7cd705ba541 100644
--- a/contrib/dblink/dblink.sql.in
+++ b/contrib/dblink/dblink.sql.in
@@ -1,146 +1,146 @@
 CREATE OR REPLACE FUNCTION dblink_connect (text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_connect'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION dblink_connect (text, text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_connect'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION dblink_disconnect ()
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_disconnect'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION dblink_disconnect (text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_disconnect'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_open (text,text)
+CREATE OR REPLACE FUNCTION dblink_open (text, text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_open'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_open (text,text,bool)
+CREATE OR REPLACE FUNCTION dblink_open (text, text, boolean)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_open'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_open (text,text,text)
+CREATE OR REPLACE FUNCTION dblink_open (text, text, text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_open'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_open (text,text,text,bool)
+CREATE OR REPLACE FUNCTION dblink_open (text, text, text, boolean)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_open'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_fetch (text,int)
+CREATE OR REPLACE FUNCTION dblink_fetch (text, int)
 RETURNS setof record
 AS 'MODULE_PATHNAME','dblink_fetch'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_fetch (text,int,bool)
+CREATE OR REPLACE FUNCTION dblink_fetch (text, int, boolean)
 RETURNS setof record
 AS 'MODULE_PATHNAME','dblink_fetch'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_fetch (text,text,int)
+CREATE OR REPLACE FUNCTION dblink_fetch (text, text, int)
 RETURNS setof record
 AS 'MODULE_PATHNAME','dblink_fetch'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_fetch (text,text,int,bool)
+CREATE OR REPLACE FUNCTION dblink_fetch (text, text, int, boolean)
 RETURNS setof record
 AS 'MODULE_PATHNAME','dblink_fetch'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION dblink_close (text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_close'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_close (text,bool)
+CREATE OR REPLACE FUNCTION dblink_close (text, boolean)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_close'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_close (text,text)
+CREATE OR REPLACE FUNCTION dblink_close (text, text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_close'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_close (text,text,bool)
+CREATE OR REPLACE FUNCTION dblink_close (text, text, boolean)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_close'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink (text,text)
+CREATE OR REPLACE FUNCTION dblink (text, text)
 RETURNS setof record
 AS 'MODULE_PATHNAME','dblink_record'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink (text,text,bool)
+CREATE OR REPLACE FUNCTION dblink (text, text, boolean)
 RETURNS setof record
 AS 'MODULE_PATHNAME','dblink_record'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION dblink (text)
 RETURNS setof record
 AS 'MODULE_PATHNAME','dblink_record'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink (text,bool)
+CREATE OR REPLACE FUNCTION dblink (text, boolean)
 RETURNS setof record
 AS 'MODULE_PATHNAME','dblink_record'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_exec (text,text)
+CREATE OR REPLACE FUNCTION dblink_exec (text, text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_exec'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_exec (text,text,bool)
+CREATE OR REPLACE FUNCTION dblink_exec (text, text, boolean)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_exec'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION dblink_exec (text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_exec'
-LANGUAGE 'c' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_exec (text,bool)
+CREATE OR REPLACE FUNCTION dblink_exec (text,boolean)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_exec'
-LANGUAGE 'c' STRICT;
+LANGUAGE C STRICT;
 
-CREATE TYPE dblink_pkey_results AS (position int4, colname text);
+CREATE TYPE dblink_pkey_results AS (position int, colname text);
 
 CREATE OR REPLACE FUNCTION dblink_get_pkey (text)
 RETURNS setof dblink_pkey_results
 AS 'MODULE_PATHNAME','dblink_get_pkey'
-LANGUAGE 'c' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_build_sql_insert (text, int2vector, int4, _text, _text)
+CREATE OR REPLACE FUNCTION dblink_build_sql_insert (text, int2vector, int, _text, _text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_build_sql_insert'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_build_sql_delete (text, int2vector, int4, _text)
+CREATE OR REPLACE FUNCTION dblink_build_sql_delete (text, int2vector, int, _text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_build_sql_delete'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
-CREATE OR REPLACE FUNCTION dblink_build_sql_update (text, int2vector, int4, _text, _text)
+CREATE OR REPLACE FUNCTION dblink_build_sql_update (text, int2vector, int, _text, _text)
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_build_sql_update'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION dblink_current_query ()
 RETURNS text
 AS 'MODULE_PATHNAME','dblink_current_query'
-LANGUAGE 'C';
+LANGUAGE C;
diff --git a/contrib/dbmirror/MirrorSetup.sql b/contrib/dbmirror/MirrorSetup.sql
index 18c5b0693e3..d4e378998a9 100644
--- a/contrib/dbmirror/MirrorSetup.sql
+++ b/contrib/dbmirror/MirrorSetup.sql
@@ -1,62 +1,54 @@
 BEGIN;
 
-
-CREATE FUNCTION "recordchange" () RETURNS trigger AS
-'$libdir/pending', 'recordchange' LANGUAGE 'C';
-
-
+CREATE FUNCTION "recordchange" () RETURNS trigger
+    AS '$libdir/pending', 'recordchange'
+    LANGUAGE C;
 
 CREATE TABLE dbmirror_MirrorHost (
-MirrorHostId serial not null,
-SlaveName varchar NOT NULL,
-PRIMARY KEY(MirrorHostId)
+    MirrorHostId serial PRIMARY KEY,
+    SlaveName varchar NOT NULL
 );
 
-
-
-
-
 CREATE TABLE dbmirror_Pending (
-SeqId serial,
-TableName Name NOT NULL,
-Op character,
-XID int4 NOT NULL,
-PRIMARY KEY (SeqId)
+    SeqId serial PRIMARY KEY,
+    TableName name NOT NULL,
+    Op character,
+    XID integer NOT NULL
 );
 
 CREATE INDEX dbmirror_Pending_XID_Index ON dbmirror_Pending (XID);
 
 CREATE TABLE dbmirror_PendingData (
-SeqId int4 NOT NULL,
-IsKey bool NOT NULL,
-Data varchar,
-PRIMARY KEY (SeqId, IsKey) ,
-FOREIGN KEY (SeqId) REFERENCES dbmirror_Pending (SeqId) ON UPDATE CASCADE  ON DELETE CASCADE
+    SeqId integer NOT NULL,
+    IsKey boolean NOT NULL,
+    Data varchar,
+    PRIMARY KEY (SeqId, IsKey) ,
+    FOREIGN KEY (SeqId) REFERENCES dbmirror_Pending (SeqId) ON UPDATE CASCADE  ON DELETE CASCADE
 );
 
-
 CREATE TABLE dbmirror_MirroredTransaction (
-XID int4 NOT NULL,
-LastSeqId int4 NOT NULL,
-MirrorHostId int4 NOT NULL,
-PRIMARY KEY  (XID,MirrorHostId),
-FOREIGN KEY (MirrorHostId) REFERENCES dbmirror_MirrorHost (MirrorHostId) ON UPDATE CASCADE ON DELETE CASCADE,
-FOREIGN KEY (LastSeqId) REFERENCES dbmirror_Pending (SeqId)  ON UPDATE
-CASCADE ON DELETE CASCADE
+    XID integer NOT NULL,
+    LastSeqId integer NOT NULL,
+    MirrorHostId integer NOT NULL,
+    PRIMARY KEY (XID, MirrorHostId),
+    FOREIGN KEY (MirrorHostId) REFERENCES dbmirror_MirrorHost (MirrorHostId) ON UPDATE CASCADE ON DELETE CASCADE,
+    FOREIGN KEY (LastSeqId) REFERENCES dbmirror_Pending (SeqId)  ON UPDATE CASCADE ON DELETE CASCADE
 );
 
-
 UPDATE pg_proc SET proname='nextval_pg' WHERE proname='nextval';
 
-CREATE FUNCTION pg_catalog.nextval(regclass) RETURNS int8 AS
-  '$libdir/pending', 'nextval_mirror' LANGUAGE 'C' STRICT;
-
+CREATE FUNCTION pg_catalog.nextval(regclass) RETURNS bigint
+    AS '$libdir/pending', 'nextval_mirror'
+    LANGUAGE C STRICT;
 
 UPDATE pg_proc set proname='setval_pg' WHERE proname='setval';
 
-CREATE FUNCTION pg_catalog.setval(regclass, int8, boolean) RETURNS int8 AS
-  '$libdir/pending', 'setval3_mirror' LANGUAGE 'C' STRICT;
-CREATE FUNCTION pg_catalog.setval(regclass, int8) RETURNS int8 AS
-  '$libdir/pending', 'setval_mirror' LANGUAGE 'C' STRICT;
+CREATE FUNCTION pg_catalog.setval(regclass, bigint, boolean) RETURNS bigint
+    AS '$libdir/pending', 'setval3_mirror'
+    LANGUAGE C STRICT;
+
+CREATE FUNCTION pg_catalog.setval(regclass, bigint) RETURNS bigint
+    AS '$libdir/pending', 'setval_mirror'
+    LANGUAGE C STRICT;
 
 COMMIT;
diff --git a/contrib/earthdistance/earthdistance.sql.in b/contrib/earthdistance/earthdistance.sql.in
index b5de7534434..3811b1d77f5 100644
--- a/contrib/earthdistance/earthdistance.sql.in
+++ b/contrib/earthdistance/earthdistance.sql.in
@@ -8,7 +8,7 @@ SET search_path = public;
 -- in order to use different units (or a better value for the Earth's radius).
 
 CREATE OR REPLACE FUNCTION earth() RETURNS float8
-LANGUAGE 'sql' IMMUTABLE
+LANGUAGE SQL IMMUTABLE
 AS 'SELECT \'6378168\'::float8';
 
 -- Astromers may want to change the earth function so that distances will be
@@ -17,7 +17,7 @@ AS 'SELECT \'6378168\'::float8';
 -- tests.
 --
 -- CREATE OR REPLACE FUNCTION earth() RETURNS float8
--- LANGUAGE 'sql' IMMUTABLE
+-- LANGUAGE SQL IMMUTABLE
 -- AS 'SELECT 180/pi()';
 
 -- Define domain for locations on the surface of the earth using a cube
@@ -35,43 +35,43 @@ CREATE DOMAIN earth AS cube
 
 CREATE OR REPLACE FUNCTION sec_to_gc(float8) 
 RETURNS float8
-LANGUAGE 'sql'
+LANGUAGE SQL
 IMMUTABLE STRICT
 AS 'SELECT CASE WHEN $1 < 0 THEN 0::float8 WHEN $1/(2*earth()) > 1 THEN pi()*earth() ELSE 2*earth()*asin($1/(2*earth())) END';
 
 CREATE OR REPLACE FUNCTION gc_to_sec(float8)
 RETURNS float8
-LANGUAGE 'sql'
+LANGUAGE SQL
 IMMUTABLE STRICT
 AS 'SELECT CASE WHEN $1 < 0 THEN 0::float8 WHEN $1/earth() > pi() THEN 2*earth() ELSE 2*earth()*sin($1/(2*earth())) END';
 
 CREATE OR REPLACE FUNCTION ll_to_earth(float8, float8)
 RETURNS earth
-LANGUAGE 'sql'
+LANGUAGE SQL
 IMMUTABLE STRICT
 AS 'SELECT cube(cube(cube(earth()*cos(radians($1))*cos(radians($2))),earth()*cos(radians($1))*sin(radians($2))),earth()*sin(radians($1)))::earth';
 
 CREATE OR REPLACE FUNCTION latitude(earth)
 RETURNS float8
-LANGUAGE 'sql'
+LANGUAGE SQL
 IMMUTABLE STRICT
 AS 'SELECT CASE WHEN cube_ll_coord($1, 3)/earth() < -1 THEN -90::float8 WHEN cube_ll_coord($1, 3)/earth() > 1 THEN 90::float8 ELSE degrees(asin(cube_ll_coord($1, 3)/earth())) END';
 
 CREATE OR REPLACE FUNCTION longitude(earth)
 RETURNS float8
-LANGUAGE 'sql'
+LANGUAGE SQL
 IMMUTABLE STRICT
 AS 'SELECT degrees(atan2(cube_ll_coord($1, 2), cube_ll_coord($1, 1)))';
 
 CREATE OR REPLACE FUNCTION earth_distance(earth, earth)
 RETURNS float8
-LANGUAGE 'sql'
+LANGUAGE SQL
 IMMUTABLE STRICT
 AS 'SELECT sec_to_gc(cube_distance($1, $2))';
 
 CREATE OR REPLACE FUNCTION earth_box(earth, float8)
 RETURNS cube
-LANGUAGE 'sql'
+LANGUAGE SQL
 IMMUTABLE STRICT
 AS 'SELECT cube_enlarge($1, gc_to_sec($2), 3)';
   
@@ -79,7 +79,7 @@ AS 'SELECT cube_enlarge($1, gc_to_sec($2), 3)';
 
 CREATE OR REPLACE FUNCTION geo_distance (point, point)
 RETURNS float8
-LANGUAGE 'C' IMMUTABLE STRICT AS 'MODULE_PATHNAME';
+LANGUAGE C IMMUTABLE STRICT AS 'MODULE_PATHNAME';
 
 --------------- geo_distance as operator <@>
 
diff --git a/contrib/fulltextindex/README.fti b/contrib/fulltextindex/README.fti
index 2425288b835..c2a24096c36 100644
--- a/contrib/fulltextindex/README.fti
+++ b/contrib/fulltextindex/README.fti
@@ -58,7 +58,7 @@ sub-string will fit.
 The create the function that contains the trigger::
 
 	create function fti() returns trigger as
-	    '/path/to/fti.so' language 'C';
+	    '/path/to/fti.so' language C;
 
 And finally define the trigger on the 'cds' table:
 
diff --git a/contrib/fulltextindex/fti.c b/contrib/fulltextindex/fti.c
index a3ac6da586f..9e120dc8920 100644
--- a/contrib/fulltextindex/fti.c
+++ b/contrib/fulltextindex/fti.c
@@ -22,7 +22,7 @@
  *
  *	-- Create the SQL function based on the compiled shared object
  *	create function fti() returns trigger as
- *	  '/usr/local/pgsql/lib/contrib/fti.so' language 'C';
+ *	  '/usr/local/pgsql/lib/contrib/fti.so' language C;
  *
  *	-- Create the FTI table
  *	create table product_fti (string varchar(255), id oid) without oids;
diff --git a/contrib/fulltextindex/fti.pl b/contrib/fulltextindex/fti.pl
index 17f000149b7..4feb51964f7 100644
--- a/contrib/fulltextindex/fti.pl
+++ b/contrib/fulltextindex/fti.pl
@@ -29,7 +29,7 @@
 #
 #		create function fti() returns trigger as
 #			'/path/to/fti/file/fti.so'
-#		language 'C';
+#		language C;
 #
 #		create trigger my_fti_trigger after update or insert or delete
 #			on mytable
diff --git a/contrib/fulltextindex/fti.sql.in b/contrib/fulltextindex/fti.sql.in
index 93eff0f633d..c060ee8757e 100644
--- a/contrib/fulltextindex/fti.sql.in
+++ b/contrib/fulltextindex/fti.sql.in
@@ -3,4 +3,4 @@ SET search_path = public;
 
 CREATE OR REPLACE FUNCTION fti() RETURNS trigger AS
 	'MODULE_PATHNAME', 'fti'
-	LANGUAGE 'C' VOLATILE CALLED ON NULL INPUT;
+	LANGUAGE C VOLATILE CALLED ON NULL INPUT;
diff --git a/contrib/fuzzystrmatch/README.soundex b/contrib/fuzzystrmatch/README.soundex
index 5a58655cdcf..cb33c64469d 100644
--- a/contrib/fuzzystrmatch/README.soundex
+++ b/contrib/fuzzystrmatch/README.soundex
@@ -20,58 +20,47 @@ SELECT soundex('Anne'), soundex('Ann'), difference('Anne', 'Ann');
 SELECT soundex('Anne'), soundex('Andrew'), difference('Anne', 'Andrew');
 SELECT soundex('Anne'), soundex('Margaret'), difference('Anne', 'Margaret');
 
-CREATE TABLE s (nm text)\g
+CREATE TABLE s (nm text);
 
-insert into s values ('john')\g
-insert into s values ('joan')\g
-insert into s values ('wobbly')\g
-insert into s values ('jack')\g
+INSERT INTO s VALUES ('john');
+INSERT INTO s VALUES ('joan');
+INSERT INTO s VALUES ('wobbly');
+INSERT INTO s VALUES ('jack');
 
-select * from s
-where soundex(nm) = soundex('john')\g
+SELECT * FROM s WHERE soundex(nm) = soundex('john');
 
-select a.nm, b.nm from s a, s b
-where soundex(a.nm) = soundex(b.nm)
-and a.oid <> b.oid\g
+SELECT a.nm, b.nm FROM s a, s b WHERE soundex(a.nm) = soundex(b.nm) AND a.oid <> b.oid;
 
-CREATE FUNCTION text_sx_eq(text, text) RETURNS bool AS
+CREATE FUNCTION text_sx_eq(text, text) RETURNS boolean AS
 'select soundex($1) = soundex($2)'
-LANGUAGE 'sql'\g
+LANGUAGE SQL;
 
-CREATE FUNCTION text_sx_lt(text,text) RETURNS bool AS
+CREATE FUNCTION text_sx_lt(text, text) RETURNS boolean AS
 'select soundex($1) < soundex($2)'
-LANGUAGE 'sql'\g
+LANGUAGE SQL;
 
-CREATE FUNCTION text_sx_gt(text,text) RETURNS bool AS
+CREATE FUNCTION text_sx_gt(text, text) RETURNS boolean AS
 'select soundex($1) > soundex($2)'
-LANGUAGE 'sql';
+LANGUAGE SQL;
 
-CREATE FUNCTION text_sx_le(text,text) RETURNS bool AS
+CREATE FUNCTION text_sx_le(text, text) RETURNS boolean AS
 'select soundex($1) <= soundex($2)'
-LANGUAGE 'sql';
+LANGUAGE SQL;
 
-CREATE FUNCTION text_sx_ge(text,text) RETURNS bool AS
+CREATE FUNCTION text_sx_ge(text, text) RETURNS boolean AS
 'select soundex($1) >= soundex($2)'
-LANGUAGE 'sql';
+LANGUAGE SQL;
 
-CREATE FUNCTION text_sx_ne(text,text) RETURNS bool AS
+CREATE FUNCTION text_sx_ne(text, text) RETURNS boolean AS
 'select soundex($1) <> soundex($2)'
-LANGUAGE 'sql';
+LANGUAGE SQL;
 
-DROP OPERATOR #= (text,text)\g
+DROP OPERATOR #= (text, text);
 
-CREATE OPERATOR #= (leftarg=text, rightarg=text, procedure=text_sx_eq,
-commutator = #=)\g
+CREATE OPERATOR #= (leftarg=text, rightarg=text, procedure=text_sx_eq, commutator = #=);
 
-SELECT *
-FROM s
-WHERE text_sx_eq(nm,'john')\g
+SELECT * FROM s WHERE text_sx_eq(nm, 'john');
 
-SELECT *
-FROM s
-WHERE s.nm #= 'john';
-
-SELECT *
-FROM s
-WHERE difference(s.nm, 'john') > 2;
+SELECT * FROM s WHERE s.nm #= 'john';
 
+SELECT * FROM s WHERE difference(s.nm, 'john') > 2;
diff --git a/contrib/intarray/_int.sql.in b/contrib/intarray/_int.sql.in
index f0b35b21818..b9d33a7a43a 100644
--- a/contrib/intarray/_int.sql.in
+++ b/contrib/intarray/_int.sql.in
@@ -10,12 +10,12 @@ SET search_path = public;
 CREATE FUNCTION bqarr_in(cstring)
 RETURNS query_int
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION bqarr_out(query_int)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE query_int (
 	INTERNALLENGTH = -1,
@@ -27,20 +27,20 @@ CREATE TYPE query_int (
 CREATE FUNCTION querytree(query_int)
 RETURNS text
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 
 CREATE FUNCTION boolop(_int4, query_int)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 COMMENT ON FUNCTION boolop(_int4, query_int) IS 'boolean operation with array';
 
 CREATE FUNCTION rboolop(query_int, _int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 COMMENT ON FUNCTION rboolop(query_int, _int4) IS 'boolean operation with array';
 
@@ -72,35 +72,35 @@ CREATE OPERATOR ~~ (
 CREATE FUNCTION _int_contains(_int4, _int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 COMMENT ON FUNCTION _int_contains(_int4, _int4) IS 'contains';
 
 CREATE FUNCTION _int_contained(_int4, _int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 COMMENT ON FUNCTION _int_contained(_int4, _int4) IS 'contained in';
 
 CREATE FUNCTION _int_overlap(_int4, _int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 COMMENT ON FUNCTION _int_overlap(_int4, _int4) IS 'overlaps';
 
 CREATE FUNCTION _int_same(_int4, _int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 COMMENT ON FUNCTION _int_same(_int4, _int4) IS 'same as';
 
 CREATE FUNCTION _int_different(_int4, _int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 COMMENT ON FUNCTION _int_different(_int4, _int4) IS 'different';
 
@@ -108,12 +108,13 @@ COMMENT ON FUNCTION _int_different(_int4, _int4) IS 'different';
 
 CREATE FUNCTION _int_union(_int4, _int4)
 RETURNS _int4
-AS 'MODULE_PATHNAME' LANGUAGE 'C' WITH (isstrict);
+AS 'MODULE_PATHNAME'
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION _int_inter(_int4, _int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 --
 -- OPERATORS
@@ -172,12 +173,12 @@ CREATE OPERATOR ~ (
 CREATE FUNCTION intset(int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION icount(_int4)
 RETURNS int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR # (
 	RIGHTARG = _int4,
@@ -187,32 +188,32 @@ CREATE OPERATOR # (
 CREATE FUNCTION sort(_int4, text)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION sort(_int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION sort_asc(_int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION sort_desc(_int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION uniq(_int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION idx(_int4, int4)
 RETURNS int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR # (
 	LEFTARG = _int4,
@@ -223,17 +224,17 @@ CREATE OPERATOR # (
 CREATE FUNCTION subarray(_int4, int4, int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION subarray(_int4, int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION intarray_push_elem(_int4, int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR + (
 	LEFTARG = _int4,
@@ -244,7 +245,7 @@ CREATE OPERATOR + (
 CREATE FUNCTION intarray_push_array(_int4, _int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR + (
 	LEFTARG = _int4,
@@ -256,7 +257,7 @@ CREATE OPERATOR + (
 CREATE FUNCTION intarray_del_elem(_int4, int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR - (
 	LEFTARG = _int4,
@@ -267,7 +268,7 @@ CREATE OPERATOR - (
 CREATE FUNCTION intset_union_elem(_int4, int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR | (
 	LEFTARG = _int4,
@@ -285,7 +286,7 @@ CREATE OPERATOR | (
 CREATE FUNCTION intset_subtract(_int4, _int4)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict, isCachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR - (
 	LEFTARG = _int4,
@@ -305,37 +306,37 @@ CREATE OPERATOR & (
 CREATE FUNCTION g_int_consistent(internal,_int4,int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION g_int_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION g_int_decompress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION g_int_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION g_int_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION g_int_union(internal, internal)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION g_int_same(_int4, _int4, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 
 -- Create the operator class for indexing
@@ -364,12 +365,12 @@ DEFAULT FOR TYPE _int4 USING gist AS
 CREATE FUNCTION _intbig_in(cstring)
 RETURNS intbig_gkey
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION _intbig_out(intbig_gkey)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE intbig_gkey (
         INTERNALLENGTH = -1,
@@ -380,37 +381,37 @@ CREATE TYPE intbig_gkey (
 CREATE FUNCTION g_intbig_consistent(internal,internal,int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION g_intbig_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION g_intbig_decompress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION g_intbig_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION g_intbig_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION g_intbig_union(internal, internal)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION g_intbig_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- register the opclass for indexing (not as default)
 
diff --git a/contrib/intarray/expected/_int.out b/contrib/intarray/expected/_int.out
index 0094bdcd602..85c8d8bb142 100644
--- a/contrib/intarray/expected/_int.out
+++ b/contrib/intarray/expected/_int.out
@@ -6,9 +6,9 @@
 psql:_int.sql:13: NOTICE:  type "query_int" is not yet defined
 DETAIL:  Creating a shell type definition.
 psql:_int.sql:18: NOTICE:  argument type query_int is only a shell
-psql:_int.sql:367: NOTICE:  type "intbig_gkey" is not yet defined
+psql:_int.sql:368: NOTICE:  type "intbig_gkey" is not yet defined
 DETAIL:  Creating a shell type definition.
-psql:_int.sql:372: NOTICE:  argument type intbig_gkey is only a shell
+psql:_int.sql:373: NOTICE:  argument type intbig_gkey is only a shell
 SELECT intset(1234);
  intset 
 --------
diff --git a/contrib/isbn_issn/isbn_issn.sql.in b/contrib/isbn_issn/isbn_issn.sql.in
index 740296cdf73..1fb0b5ffb49 100644
--- a/contrib/isbn_issn/isbn_issn.sql.in
+++ b/contrib/isbn_issn/isbn_issn.sql.in
@@ -1,7 +1,7 @@
 --
 --	PostgreSQL code for ISSNs.
 --
---	$PostgreSQL: pgsql/contrib/isbn_issn/isbn_issn.sql.in,v 1.11 2005/01/29 22:35:02 tgl Exp $
+--	$PostgreSQL: pgsql/contrib/isbn_issn/isbn_issn.sql.in,v 1.12 2006/02/27 16:09:48 petere Exp $
 --
 
 -- Adjust this setting to control where the objects get created.
@@ -120,7 +120,7 @@ CREATE OPERATOR <> (
 CREATE FUNCTION issn_cmp(issn, issn)
 RETURNS integer
 AS '$libdir/isbn_issn'
-LANGUAGE c STRICT;
+LANGUAGE C STRICT;
 
 -- Create default operator class for 'issn'    --
 -- Needed to create index or primary key       --
@@ -253,7 +253,7 @@ CREATE OPERATOR <> (
 CREATE FUNCTION isbn_cmp(isbn, isbn)
 RETURNS integer
 AS '$libdir/isbn_issn'
-LANGUAGE c STRICT;
+LANGUAGE C STRICT;
 
 -- Create default operator class for 'isbn'    --
 -- Needed to create index or primary key       --
diff --git a/contrib/ltree/README.ltree b/contrib/ltree/README.ltree
index 55b15d0f822..a9d722d0514 100644
--- a/contrib/ltree/README.ltree
+++ b/contrib/ltree/README.ltree
@@ -313,7 +313,7 @@ ltreetest=# select subpath(path,0,2)||'Space'||subpath(path,2) from test where p
 We could create SQL-function:
 CREATE FUNCTION ins_label(ltree, int4, text) RETURNS ltree 
 AS 'select subpath($1,0,$2) || $3 || subpath($1,$2);'
-LANGUAGE SQL WITH (ISCACHABLE);
+LANGUAGE SQL IMMUTABLE;
 
 and previous select could be rewritten as:
 
@@ -329,7 +329,7 @@ Or with another arguments:
 
 CREATE FUNCTION ins_label(ltree, ltree, text) RETURNS ltree
 AS 'select subpath($1,0,nlevel($2)) || $3 || subpath($1,nlevel($2));'
-LANGUAGE SQL WITH (ISCACHABLE);
+LANGUAGE SQL IMMUTABLE;
 
 ltreetest=# select ins_label(path,'Top.Science'::ltree,'Space') from test where path <@ 'Top.Science.Astronomy';
                 ins_label                 
diff --git a/contrib/ltree/ltree.sql.in b/contrib/ltree/ltree.sql.in
index e80c391ab0e..8e7d5680a84 100644
--- a/contrib/ltree/ltree.sql.in
+++ b/contrib/ltree/ltree.sql.in
@@ -4,12 +4,12 @@ SET search_path = public;
 CREATE FUNCTION ltree_in(cstring)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION ltree_out(ltree)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE ltree (
 	INTERNALLENGTH = -1,
@@ -23,37 +23,37 @@ CREATE TYPE ltree (
 CREATE FUNCTION ltree_cmp(ltree,ltree)
 RETURNS int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_lt(ltree,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_le(ltree,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_eq(ltree,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_ge(ltree,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_gt(ltree,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_ne(ltree,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 
 CREATE OPERATOR < (
@@ -123,107 +123,107 @@ CREATE OPERATOR <> (
 CREATE FUNCTION subltree(ltree,int4,int4)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION subpath(ltree,int4,int4)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION subpath(ltree,int4)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION index(ltree,ltree)
 RETURNS int4
 AS 'MODULE_PATHNAME', 'ltree_index'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION index(ltree,ltree,int4)
 RETURNS int4
 AS 'MODULE_PATHNAME', 'ltree_index'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION nlevel(ltree)
 RETURNS int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree2text(ltree)
 RETURNS text
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION text2ltree(text)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION lca(_ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME','_lca'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION lca(ltree,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION lca(ltree,ltree,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION lca(ltree,ltree,ltree,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION lca(ltree,ltree,ltree,ltree,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION lca(ltree,ltree,ltree,ltree,ltree,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION lca(ltree,ltree,ltree,ltree,ltree,ltree,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION lca(ltree,ltree,ltree,ltree,ltree,ltree,ltree,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_isparent(ltree,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_risparent(ltree,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_addltree(ltree,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_addtext(ltree,text)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltree_textadd(text,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR @> (
         LEFTARG = ltree,
@@ -296,12 +296,12 @@ CREATE OPERATOR CLASS ltree_ops
 CREATE FUNCTION lquery_in(cstring)
 RETURNS lquery
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION lquery_out(lquery)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE lquery (
 	INTERNALLENGTH = -1,
@@ -313,12 +313,12 @@ CREATE TYPE lquery (
 CREATE FUNCTION ltq_regex(ltree,lquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltq_rregex(lquery,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR ~ (
         LEFTARG = ltree,
@@ -360,12 +360,12 @@ CREATE OPERATOR ^~ (
 CREATE FUNCTION lt_q_regex(ltree,_lquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION lt_q_rregex(_lquery,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR ? (
         LEFTARG = ltree,
@@ -407,12 +407,12 @@ CREATE OPERATOR ^? (
 CREATE FUNCTION ltxtq_in(cstring)
 RETURNS ltxtquery
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION ltxtq_out(ltxtquery)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE ltxtquery (
 	INTERNALLENGTH = -1,
@@ -426,12 +426,12 @@ CREATE TYPE ltxtquery (
 CREATE FUNCTION ltxtq_exec(ltree, ltxtquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION ltxtq_rexec(ltxtquery, ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR @ (
         LEFTARG = ltree,
@@ -474,12 +474,12 @@ CREATE OPERATOR ^@ (
 CREATE FUNCTION ltree_gist_in(cstring)
 RETURNS ltree_gist
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
   
 CREATE FUNCTION ltree_gist_out(ltree_gist)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
   
 CREATE TYPE ltree_gist (
 	internallength = -1,
@@ -490,19 +490,25 @@ CREATE TYPE ltree_gist (
 
 
 CREATE FUNCTION ltree_consistent(internal,internal,int2)
-RETURNS bool as 'MODULE_PATHNAME' language 'C';
+RETURNS bool as 'MODULE_PATHNAME' LANGUAGE C;
+
 CREATE FUNCTION ltree_compress(internal)
-RETURNS internal as 'MODULE_PATHNAME' language 'C';
+RETURNS internal as 'MODULE_PATHNAME' LANGUAGE C;
+
 CREATE FUNCTION ltree_decompress(internal)
-RETURNS internal as 'MODULE_PATHNAME' language 'C';
+RETURNS internal as 'MODULE_PATHNAME' LANGUAGE C;
+
 CREATE FUNCTION ltree_penalty(internal,internal,internal)
-RETURNS internal as 'MODULE_PATHNAME' language 'C' with(isstrict);
+RETURNS internal as 'MODULE_PATHNAME' LANGUAGE C RETURNS NULL ON NULL INPUT;
+
 CREATE FUNCTION ltree_picksplit(internal, internal)
-RETURNS internal as 'MODULE_PATHNAME' language 'C';
+RETURNS internal as 'MODULE_PATHNAME' LANGUAGE C;
+
 CREATE FUNCTION ltree_union(internal, internal)
-RETURNS int4 as 'MODULE_PATHNAME' language 'C';
+RETURNS int4 as 'MODULE_PATHNAME' LANGUAGE C;
+
 CREATE FUNCTION ltree_same(internal, internal, internal)
-RETURNS internal as 'MODULE_PATHNAME' language 'C';
+RETURNS internal as 'MODULE_PATHNAME' LANGUAGE C;
 
 CREATE OPERATOR CLASS gist_ltree_ops
     DEFAULT FOR TYPE ltree USING gist AS
@@ -534,52 +540,52 @@ CREATE OPERATOR CLASS gist_ltree_ops
 CREATE FUNCTION _ltree_isparent(_ltree,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION _ltree_r_isparent(ltree,_ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION _ltree_risparent(_ltree,ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION _ltree_r_risparent(ltree,_ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION _ltq_regex(_ltree,lquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION _ltq_rregex(lquery,_ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION _lt_q_regex(_ltree,_lquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION _lt_q_rregex(_lquery,_ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION _ltxtq_exec(_ltree, ltxtquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION _ltxtq_rexec(ltxtquery, _ltree)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR @> (
         LEFTARG = _ltree,
@@ -767,7 +773,7 @@ CREATE OPERATOR ^@ (
 CREATE FUNCTION _ltree_extract_isparent(_ltree,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR ?@> (
         LEFTARG = _ltree,
@@ -778,7 +784,7 @@ CREATE OPERATOR ?@> (
 CREATE FUNCTION _ltree_extract_risparent(_ltree,ltree)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR ?<@ (
         LEFTARG = _ltree,
@@ -789,7 +795,7 @@ CREATE OPERATOR ?<@ (
 CREATE FUNCTION _ltq_extract_regex(_ltree,lquery)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR ?~ (
         LEFTARG = _ltree,
@@ -800,7 +806,7 @@ CREATE OPERATOR ?~ (
 CREATE FUNCTION _ltxtq_extract_exec(_ltree,ltxtquery)
 RETURNS ltree
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR ?@ (
         LEFTARG = _ltree,
@@ -812,27 +818,32 @@ CREATE OPERATOR ?@ (
 CREATE FUNCTION _ltree_consistent(internal,internal,int2)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
+
 CREATE FUNCTION _ltree_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
+
 CREATE FUNCTION _ltree_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH(isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
+
 CREATE FUNCTION _ltree_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
+
 CREATE FUNCTION _ltree_union(internal, internal)
 RETURNS int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
+
 CREATE FUNCTION _ltree_same(internal, internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE OPERATOR CLASS gist__ltree_ops
     DEFAULT FOR TYPE _ltree USING gist AS
diff --git a/contrib/mac/createoui b/contrib/mac/createoui
index 56d81c20d36..ec1edcfa175 100755
--- a/contrib/mac/createoui
+++ b/contrib/mac/createoui
@@ -42,7 +42,7 @@ create index macoui_idx on macoui (addr);
 create function manuf (macaddr)
 	returns text as '
 		select name from macoui m where trunc(\$1) = m.addr;
-' language 'SQL';
+' language SQL;
 EOF
 
 if [ $update -gt 0 ]; then
diff --git a/contrib/pg_buffercache/pg_buffercache.sql.in b/contrib/pg_buffercache/pg_buffercache.sql.in
index 1dd0b2eae6c..85c7b2869a2 100644
--- a/contrib/pg_buffercache/pg_buffercache.sql.in
+++ b/contrib/pg_buffercache/pg_buffercache.sql.in
@@ -5,7 +5,7 @@ SET search_path = public;
 CREATE OR REPLACE FUNCTION pg_buffercache_pages()
 RETURNS SETOF RECORD
 AS 'MODULE_PATHNAME', 'pg_buffercache_pages'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create a view for convenient access.
 CREATE VIEW pg_buffercache AS
diff --git a/contrib/pg_freespacemap/pg_freespacemap.sql.in b/contrib/pg_freespacemap/pg_freespacemap.sql.in
index a185186518d..26574ea1c09 100644
--- a/contrib/pg_freespacemap/pg_freespacemap.sql.in
+++ b/contrib/pg_freespacemap/pg_freespacemap.sql.in
@@ -6,7 +6,7 @@ SET search_path = public;
 CREATE OR REPLACE FUNCTION pg_freespacemap()
 RETURNS SETOF RECORD
 AS 'MODULE_PATHNAME', 'pg_freespacemap'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- Create a view for convenient access.
 CREATE VIEW pg_freespacemap AS
diff --git a/contrib/pg_trgm/pg_trgm.sql.in b/contrib/pg_trgm/pg_trgm.sql.in
index f38abb6e48b..6ee16f6e230 100644
--- a/contrib/pg_trgm/pg_trgm.sql.in
+++ b/contrib/pg_trgm/pg_trgm.sql.in
@@ -5,27 +5,27 @@ BEGIN;
 create function set_limit(float4)
 returns float4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 create function show_limit()
 returns float4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 create function show_trgm(text)
 returns _text
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 create function similarity(text,text)
 returns float4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 create function similarity_op(text,text)
 returns bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR % (
         LEFTARG = text,
@@ -40,12 +40,12 @@ CREATE OPERATOR % (
 CREATE FUNCTION gtrgm_in(cstring)
 RETURNS gtrgm
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gtrgm_out(gtrgm)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE gtrgm (
         INTERNALLENGTH = -1,
@@ -57,37 +57,37 @@ CREATE TYPE gtrgm (
 CREATE FUNCTION gtrgm_consistent(gtrgm,internal,int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
  
 CREATE FUNCTION gtrgm_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtrgm_decompress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtrgm_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gtrgm_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtrgm_union(bytea, internal)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtrgm_same(gtrgm, gtrgm, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- create the operator class
 CREATE OPERATOR CLASS gist_trgm_ops
diff --git a/contrib/pgcrypto/pgcrypto.sql.in b/contrib/pgcrypto/pgcrypto.sql.in
index fb3949d56e4..a6ff645c4fc 100644
--- a/contrib/pgcrypto/pgcrypto.sql.in
+++ b/contrib/pgcrypto/pgcrypto.sql.in
@@ -4,72 +4,72 @@ SET search_path = public;
 CREATE OR REPLACE FUNCTION digest(text, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pg_digest'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION digest(bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pg_digest'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION digest_exists(text)
 RETURNS bool
 AS 'MODULE_PATHNAME', 'pg_digest_exists'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION hmac(text, text, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pg_hmac'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION hmac(bytea, bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pg_hmac'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION hmac_exists(text)
 RETURNS bool
 AS 'MODULE_PATHNAME', 'pg_hmac_exists'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION crypt(text, text)
 RETURNS text
 AS 'MODULE_PATHNAME', 'pg_crypt'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION gen_salt(text)
 RETURNS text
 AS 'MODULE_PATHNAME', 'pg_gen_salt'
-LANGUAGE 'C' VOLATILE STRICT;
+LANGUAGE C VOLATILE STRICT;
 
 CREATE OR REPLACE FUNCTION gen_salt(text, int4)
 RETURNS text
 AS 'MODULE_PATHNAME', 'pg_gen_salt_rounds'
-LANGUAGE 'C' VOLATILE STRICT;
+LANGUAGE C VOLATILE STRICT;
 
 CREATE OR REPLACE FUNCTION encrypt(bytea, bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pg_encrypt'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION decrypt(bytea, bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pg_decrypt'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION encrypt_iv(bytea, bytea, bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pg_encrypt_iv'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION decrypt_iv(bytea, bytea, bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pg_decrypt_iv'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION cipher_exists(text)
 RETURNS bool
 AS 'MODULE_PATHNAME', 'pg_cipher_exists'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 --
 -- pgp_sym_encrypt(data, key)
@@ -77,12 +77,12 @@ LANGUAGE 'C' IMMUTABLE STRICT;
 CREATE OR REPLACE FUNCTION pgp_sym_encrypt(text, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_sym_encrypt_text'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION pgp_sym_encrypt_bytea(bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_sym_encrypt_bytea'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 --
 -- pgp_sym_encrypt(data, key, args)
@@ -90,12 +90,12 @@ LANGUAGE 'C' STRICT;
 CREATE OR REPLACE FUNCTION pgp_sym_encrypt(text, text, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_sym_encrypt_text'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION pgp_sym_encrypt_bytea(bytea, text, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_sym_encrypt_bytea'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 --
 -- pgp_sym_decrypt(data, key)
@@ -103,12 +103,12 @@ LANGUAGE 'C' STRICT;
 CREATE OR REPLACE FUNCTION pgp_sym_decrypt(bytea, text)
 RETURNS text
 AS 'MODULE_PATHNAME', 'pgp_sym_decrypt_text'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION pgp_sym_decrypt_bytea(bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_sym_decrypt_bytea'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 --
 -- pgp_sym_decrypt(data, key, args)
@@ -116,12 +116,12 @@ LANGUAGE 'C' IMMUTABLE STRICT;
 CREATE OR REPLACE FUNCTION pgp_sym_decrypt(bytea, text, text)
 RETURNS text
 AS 'MODULE_PATHNAME', 'pgp_sym_decrypt_text'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION pgp_sym_decrypt_bytea(bytea, text, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_sym_decrypt_bytea'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 --
 -- pgp_pub_encrypt(data, key)
@@ -129,12 +129,12 @@ LANGUAGE 'C' IMMUTABLE STRICT;
 CREATE OR REPLACE FUNCTION pgp_pub_encrypt(text, bytea)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_pub_encrypt_text'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION pgp_pub_encrypt_bytea(bytea, bytea)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_pub_encrypt_bytea'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 --
 -- pgp_pub_encrypt(data, key, args)
@@ -142,12 +142,12 @@ LANGUAGE 'C' STRICT;
 CREATE OR REPLACE FUNCTION pgp_pub_encrypt(text, bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_pub_encrypt_text'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION pgp_pub_encrypt_bytea(bytea, bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_pub_encrypt_bytea'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 --
 -- pgp_pub_decrypt(data, key)
@@ -155,12 +155,12 @@ LANGUAGE 'C' STRICT;
 CREATE OR REPLACE FUNCTION pgp_pub_decrypt(bytea, bytea)
 RETURNS text
 AS 'MODULE_PATHNAME', 'pgp_pub_decrypt_text'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION pgp_pub_decrypt_bytea(bytea, bytea)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_pub_decrypt_bytea'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 --
 -- pgp_pub_decrypt(data, key, psw)
@@ -168,12 +168,12 @@ LANGUAGE 'C' IMMUTABLE STRICT;
 CREATE OR REPLACE FUNCTION pgp_pub_decrypt(bytea, bytea, text)
 RETURNS text
 AS 'MODULE_PATHNAME', 'pgp_pub_decrypt_text'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION pgp_pub_decrypt_bytea(bytea, bytea, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_pub_decrypt_bytea'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 --
 -- pgp_pub_decrypt(data, key, psw, arg)
@@ -181,12 +181,12 @@ LANGUAGE 'C' IMMUTABLE STRICT;
 CREATE OR REPLACE FUNCTION pgp_pub_decrypt(bytea, bytea, text, text)
 RETURNS text
 AS 'MODULE_PATHNAME', 'pgp_pub_decrypt_text'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION pgp_pub_decrypt_bytea(bytea, bytea, text, text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pgp_pub_decrypt_bytea'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 --
 -- PGP key ID
@@ -194,7 +194,7 @@ LANGUAGE 'C' IMMUTABLE STRICT;
 CREATE OR REPLACE FUNCTION pgp_key_id(bytea)
 RETURNS text
 AS 'MODULE_PATHNAME', 'pgp_key_id_w'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 --
 -- pgp armor
@@ -202,10 +202,10 @@ LANGUAGE 'C' IMMUTABLE STRICT;
 CREATE OR REPLACE FUNCTION armor(bytea)
 RETURNS text
 AS 'MODULE_PATHNAME', 'pg_armor'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
 CREATE OR REPLACE FUNCTION dearmor(text)
 RETURNS bytea
 AS 'MODULE_PATHNAME', 'pg_dearmor'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT;
 
diff --git a/contrib/pgstattuple/README.pgstattuple b/contrib/pgstattuple/README.pgstattuple
index 3e7facb80f0..7395b1ce319 100644
--- a/contrib/pgstattuple/README.pgstattuple
+++ b/contrib/pgstattuple/README.pgstattuple
@@ -45,11 +45,11 @@ free_percent		-- free space in %
 
    CREATE OR REPLACE FUNCTION pgstattuple(text) RETURNS pgstattuple_type
      AS 'MODULE_PATHNAME', 'pgstattuple'
-     LANGUAGE 'c' STRICT;
+     LANGUAGE C STRICT;
 
    CREATE OR REPLACE FUNCTION pgstattuple(oid) RETURNS pgstattuple_type
      AS 'MODULE_PATHNAME', 'pgstattuplebyid'
-     LANGUAGE 'c' STRICT;
+     LANGUAGE C STRICT;
 
    The argument is the table name (optionally it may be qualified)
    or the OID of the table.  Note that pgstattuple only returns
diff --git a/contrib/pgstattuple/README.pgstattuple.euc_jp b/contrib/pgstattuple/README.pgstattuple.euc_jp
index 40bfa8d3ac1..1c3c982b286 100644
--- a/contrib/pgstattuple/README.pgstattuple.euc_jp
+++ b/contrib/pgstattuple/README.pgstattuple.euc_jp
@@ -1,4 +1,4 @@
-$PostgreSQL: pgsql/contrib/pgstattuple/README.pgstattuple.euc_jp,v 1.5 2003/11/29 22:39:29 pgsql Exp $
+$PostgreSQL: pgsql/contrib/pgstattuple/README.pgstattuple.euc_jp,v 1.6 2006/02/27 16:09:49 petere Exp $
 
 pgstattuple README		2002/08/22 �а�ã��
 
@@ -54,7 +54,7 @@ free_percent		-- �����Ѳ�ǽ���ΰ补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 f7eac5040f9..440b978682c 100644
--- a/contrib/pgstattuple/pgstattuple.sql.in
+++ b/contrib/pgstattuple/pgstattuple.sql.in
@@ -16,9 +16,9 @@ CREATE TYPE pgstattuple_type AS (
 CREATE OR REPLACE FUNCTION pgstattuple(text)
 RETURNS pgstattuple_type
 AS 'MODULE_PATHNAME', 'pgstattuple'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE OR REPLACE FUNCTION pgstattuple(oid)
 RETURNS pgstattuple_type
 AS 'MODULE_PATHNAME', 'pgstattuplebyid'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
diff --git a/contrib/seg/seg.sql.in b/contrib/seg/seg.sql.in
index ca30a30ba57..94a02224a0e 100644
--- a/contrib/seg/seg.sql.in
+++ b/contrib/seg/seg.sql.in
@@ -7,12 +7,12 @@ SET search_path = public;
 CREATE FUNCTION seg_in(cstring)
 RETURNS seg
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C STRICT IMMUTABLE;
 
 CREATE FUNCTION seg_out(seg)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' IMMUTABLE STRICT;
+LANGUAGE C STRICT IMMUTABLE;
 
 CREATE TYPE seg (
 	INTERNALLENGTH = 12,
@@ -32,7 +32,7 @@ COMMENT ON TYPE seg IS
 CREATE FUNCTION seg_over_left(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_over_left(seg, seg) IS
 'overlaps or is left of';
@@ -40,7 +40,7 @@ COMMENT ON FUNCTION seg_over_left(seg, seg) IS
 CREATE FUNCTION seg_over_right(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_over_right(seg, seg) IS
 'overlaps or is right of';
@@ -48,7 +48,7 @@ COMMENT ON FUNCTION seg_over_right(seg, seg) IS
 CREATE FUNCTION seg_left(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_left(seg, seg) IS
 'is left of';
@@ -56,7 +56,7 @@ COMMENT ON FUNCTION seg_left(seg, seg) IS
 CREATE FUNCTION seg_right(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_right(seg, seg) IS
 'is right of';
@@ -67,7 +67,7 @@ COMMENT ON FUNCTION seg_right(seg, seg) IS
 CREATE FUNCTION seg_lt(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_lt(seg, seg) IS
 'less than';
@@ -75,7 +75,7 @@ COMMENT ON FUNCTION seg_lt(seg, seg) IS
 CREATE FUNCTION seg_le(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_le(seg, seg) IS
 'less than or equal';
@@ -83,7 +83,7 @@ COMMENT ON FUNCTION seg_le(seg, seg) IS
 CREATE FUNCTION seg_gt(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_gt(seg, seg) IS
 'greater than';
@@ -91,7 +91,7 @@ COMMENT ON FUNCTION seg_gt(seg, seg) IS
 CREATE FUNCTION seg_ge(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_ge(seg, seg) IS
 'greater than or equal';
@@ -99,7 +99,7 @@ COMMENT ON FUNCTION seg_ge(seg, seg) IS
 CREATE FUNCTION seg_contains(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_contains(seg, seg) IS
 'contains';
@@ -107,7 +107,7 @@ COMMENT ON FUNCTION seg_contains(seg, seg) IS
 CREATE FUNCTION seg_contained(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_contained(seg, seg) IS
 'contained in';
@@ -115,7 +115,7 @@ COMMENT ON FUNCTION seg_contained(seg, seg) IS
 CREATE FUNCTION seg_overlap(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_overlap(seg, seg) IS
 'overlaps';
@@ -123,7 +123,7 @@ COMMENT ON FUNCTION seg_overlap(seg, seg) IS
 CREATE FUNCTION seg_same(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_same(seg, seg) IS
 'same as';
@@ -131,7 +131,7 @@ COMMENT ON FUNCTION seg_same(seg, seg) IS
 CREATE FUNCTION seg_different(seg, seg)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_different(seg, seg) IS
 'different';
@@ -141,36 +141,36 @@ COMMENT ON FUNCTION seg_different(seg, seg) IS
 CREATE OR REPLACE FUNCTION seg_cmp(seg, seg)
 RETURNS int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 COMMENT ON FUNCTION seg_cmp(seg, seg) IS 'btree comparison function';
 
 CREATE FUNCTION seg_union(seg, seg)
 RETURNS seg
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 CREATE FUNCTION seg_inter(seg, seg)
 RETURNS seg
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 CREATE FUNCTION seg_size(seg)
 RETURNS float4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 -- miscellaneous
 
 CREATE FUNCTION seg_upper(seg)
 RETURNS float4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 CREATE FUNCTION seg_lower(seg)
 RETURNS float4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT IMMUTABLE;
+LANGUAGE C STRICT IMMUTABLE;
 
 
 --
@@ -304,37 +304,37 @@ CREATE OPERATOR ~ (
 CREATE FUNCTION gseg_consistent(internal,seg,int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gseg_compress(internal)
 RETURNS internal 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gseg_decompress(internal)
 RETURNS internal 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gseg_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' STRICT;
+LANGUAGE C STRICT;
 
 CREATE FUNCTION gseg_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gseg_union(internal, internal)
 RETURNS seg 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gseg_same(seg, seg, internal)
 RETURNS internal 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 
 -- Create the operator classes for indexing
diff --git a/contrib/spi/autoinc.sql.in b/contrib/spi/autoinc.sql.in
index 75889b3786d..a5d06240cce 100644
--- a/contrib/spi/autoinc.sql.in
+++ b/contrib/spi/autoinc.sql.in
@@ -4,4 +4,4 @@ SET search_path = public;
 CREATE OR REPLACE FUNCTION autoinc() 
 RETURNS trigger 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
diff --git a/contrib/spi/insert_username.sql.in b/contrib/spi/insert_username.sql.in
index 3d096592d29..7951188d4a4 100644
--- a/contrib/spi/insert_username.sql.in
+++ b/contrib/spi/insert_username.sql.in
@@ -4,4 +4,4 @@ SET search_path = public;
 CREATE OR REPLACE FUNCTION insert_username() 
 RETURNS trigger 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
diff --git a/contrib/spi/moddatetime.sql.in b/contrib/spi/moddatetime.sql.in
index 9bdaa9aefe0..d019cf2c9bb 100644
--- a/contrib/spi/moddatetime.sql.in
+++ b/contrib/spi/moddatetime.sql.in
@@ -4,4 +4,4 @@ SET search_path = public;
 CREATE OR REPLACE FUNCTION moddatetime()
 RETURNS trigger
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
diff --git a/contrib/spi/refint.sql.in b/contrib/spi/refint.sql.in
index 14b135e2580..661f1836e4f 100644
--- a/contrib/spi/refint.sql.in
+++ b/contrib/spi/refint.sql.in
@@ -4,9 +4,9 @@ SET search_path = public;
 CREATE OR REPLACE FUNCTION check_primary_key()
 RETURNS trigger
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE OR REPLACE FUNCTION check_foreign_key()
 RETURNS trigger
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
diff --git a/contrib/spi/timetravel.sql.in b/contrib/spi/timetravel.sql.in
index 675e2d9feb2..af17323f05a 100644
--- a/contrib/spi/timetravel.sql.in
+++ b/contrib/spi/timetravel.sql.in
@@ -1,19 +1,17 @@
 -- Adjust this setting to control where the objects get created.
 SET search_path = public;
 
-SET autocommit TO 'on';
-
 CREATE OR REPLACE FUNCTION timetravel() 
 RETURNS trigger 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE OR REPLACE FUNCTION set_timetravel(name, int4) 
 RETURNS int4 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE OR REPLACE FUNCTION get_timetravel(name) 
 RETURNS int4 
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isStrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
diff --git a/contrib/tablefunc/README.tablefunc b/contrib/tablefunc/README.tablefunc
index 63b1c17d8ec..08ac4c31c17 100644
--- a/contrib/tablefunc/README.tablefunc
+++ b/contrib/tablefunc/README.tablefunc
@@ -315,7 +315,7 @@ Notes
 
       CREATE OR REPLACE FUNCTION crosstab_float8_5_cols(text)
         RETURNS setof my_crosstab_float8_5_cols
-        AS '$libdir/tablefunc','crosstab' LANGUAGE 'c' STABLE STRICT;
+        AS '$libdir/tablefunc','crosstab' LANGUAGE C STABLE STRICT;
 
       B. Use OUT parameters to define the return type implicitly.
       The same example could also be done this way:
@@ -328,7 +328,7 @@ Notes
           OUT category_4 FLOAT8,
           OUT category_5 FLOAT8)
         RETURNS setof record
-        AS '$libdir/tablefunc','crosstab' LANGUAGE 'c' STABLE STRICT;
+        AS '$libdir/tablefunc','crosstab' LANGUAGE C STABLE STRICT;
 
 
 Example usage
diff --git a/contrib/tablefunc/expected/tablefunc.out b/contrib/tablefunc/expected/tablefunc.out
index 50faf4390f1..84734ea41bb 100644
--- a/contrib/tablefunc/expected/tablefunc.out
+++ b/contrib/tablefunc/expected/tablefunc.out
@@ -128,7 +128,7 @@ CREATE FUNCTION crosstab_out(text,
 	OUT rowid text, OUT att1 text, OUT att2 text, OUT att3 text)
 RETURNS setof record
 AS '$libdir/tablefunc','crosstab'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 SELECT * FROM crosstab_out('SELECT rowid, attribute, val FROM ct where rowclass = ''group1'' ORDER BY 1,2;');
  rowid | att1 | att2 | att3 
 -------+------+------+------
@@ -231,7 +231,7 @@ create type my_crosstab_result as (
 CREATE FUNCTION crosstab_named(text, text)
 RETURNS setof my_crosstab_result
 AS '$libdir/tablefunc','crosstab_hash'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 SELECT * FROM crosstab_named(
   'SELECT rowid, rowdt, attribute, val FROM cth ORDER BY 1',
   'SELECT DISTINCT attribute FROM cth ORDER BY 1');
@@ -248,7 +248,7 @@ CREATE FUNCTION crosstab_out(text, text,
   OUT test_startdate timestamp, OUT volts float8)
 RETURNS setof record
 AS '$libdir/tablefunc','crosstab_hash'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 SELECT * FROM crosstab_out(
   'SELECT rowid, rowdt, attribute, val FROM cth ORDER BY 1',
   'SELECT DISTINCT attribute FROM cth ORDER BY 1');
diff --git a/contrib/tablefunc/sql/tablefunc.sql b/contrib/tablefunc/sql/tablefunc.sql
index 32290861330..c6054c8efc9 100644
--- a/contrib/tablefunc/sql/tablefunc.sql
+++ b/contrib/tablefunc/sql/tablefunc.sql
@@ -44,7 +44,7 @@ CREATE FUNCTION crosstab_out(text,
 	OUT rowid text, OUT att1 text, OUT att2 text, OUT att3 text)
 RETURNS setof record
 AS '$libdir/tablefunc','crosstab'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 SELECT * FROM crosstab_out('SELECT rowid, attribute, val FROM ct where rowclass = ''group1'' ORDER BY 1,2;');
 
@@ -119,7 +119,7 @@ create type my_crosstab_result as (
 CREATE FUNCTION crosstab_named(text, text)
 RETURNS setof my_crosstab_result
 AS '$libdir/tablefunc','crosstab_hash'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 SELECT * FROM crosstab_named(
   'SELECT rowid, rowdt, attribute, val FROM cth ORDER BY 1',
@@ -133,7 +133,7 @@ CREATE FUNCTION crosstab_out(text, text,
   OUT test_startdate timestamp, OUT volts float8)
 RETURNS setof record
 AS '$libdir/tablefunc','crosstab_hash'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 SELECT * FROM crosstab_out(
   'SELECT rowid, rowdt, attribute, val FROM cth ORDER BY 1',
diff --git a/contrib/tablefunc/tablefunc.sql.in b/contrib/tablefunc/tablefunc.sql.in
index fee9cb7e17b..416e23ccc79 100644
--- a/contrib/tablefunc/tablefunc.sql.in
+++ b/contrib/tablefunc/tablefunc.sql.in
@@ -4,13 +4,13 @@ SET search_path = public;
 CREATE OR REPLACE FUNCTION normal_rand(int4, float8, float8)
 RETURNS setof float8
 AS 'MODULE_PATHNAME','normal_rand'
-LANGUAGE 'C' VOLATILE STRICT;
+LANGUAGE C VOLATILE STRICT;
 
 -- the generic crosstab function:
 CREATE OR REPLACE FUNCTION crosstab(text)
 RETURNS setof record
 AS 'MODULE_PATHNAME','crosstab'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 -- examples of building custom type-specific crosstab functions:
 CREATE TYPE tablefunc_crosstab_2 AS
@@ -40,47 +40,47 @@ CREATE TYPE tablefunc_crosstab_4 AS
 CREATE OR REPLACE FUNCTION crosstab2(text)
 RETURNS setof tablefunc_crosstab_2
 AS 'MODULE_PATHNAME','crosstab'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 CREATE OR REPLACE FUNCTION crosstab3(text)
 RETURNS setof tablefunc_crosstab_3
 AS 'MODULE_PATHNAME','crosstab'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 CREATE OR REPLACE FUNCTION crosstab4(text)
 RETURNS setof tablefunc_crosstab_4
 AS 'MODULE_PATHNAME','crosstab'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 -- obsolete:
 CREATE OR REPLACE FUNCTION crosstab(text,int)
 RETURNS setof record
 AS 'MODULE_PATHNAME','crosstab'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 CREATE OR REPLACE FUNCTION crosstab(text,text)
 RETURNS setof record
 AS 'MODULE_PATHNAME','crosstab_hash'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 CREATE OR REPLACE FUNCTION connectby(text,text,text,text,int,text)
 RETURNS setof record
 AS 'MODULE_PATHNAME','connectby_text'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 CREATE OR REPLACE FUNCTION connectby(text,text,text,text,int)
 RETURNS setof record
 AS 'MODULE_PATHNAME','connectby_text'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 -- These 2 take the name of a field to ORDER BY as 4th arg (for sorting siblings)
 
 CREATE OR REPLACE FUNCTION connectby(text,text,text,text,text,int,text)
 RETURNS setof record
 AS 'MODULE_PATHNAME','connectby_text_serial'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
 
 CREATE OR REPLACE FUNCTION connectby(text,text,text,text,text,int)
 RETURNS setof record
 AS 'MODULE_PATHNAME','connectby_text_serial'
-LANGUAGE 'C' STABLE STRICT;
+LANGUAGE C STABLE STRICT;
diff --git a/contrib/tsearch2/gendict/sql.IN b/contrib/tsearch2/gendict/sql.IN
index 044230b4173..399b26b0d9e 100644
--- a/contrib/tsearch2/gendict/sql.IN
+++ b/contrib/tsearch2/gendict/sql.IN
@@ -4,13 +4,13 @@ BEGIN;
 HASINIT create function dinit_CFG_MODNAME(internal)
 HASINIT         returns internal
 HASINIT         as 'MODULE_PATHNAME'
-HASINIT         language 'C';
+HASINIT         language C;
 
 NOSNOWBALL create function dlexize_CFG_MODNAME(internal,internal,int4)
 NOSNOWBALL        returns internal
 NOSNOWBALL        as 'MODULE_PATHNAME'
-NOSNOWBALL        language 'C'
-NOSNOWBALL        with (isstrict);
+NOSNOWBALL        language C
+NOSNOWBALL        returns null on null input;
 
 insert into pg_ts_dict select
         'CFG_MODNAME',
diff --git a/contrib/tsearch2/tsearch.sql.in b/contrib/tsearch2/tsearch.sql.in
index 07290838fff..c30a80e51ff 100644
--- a/contrib/tsearch2/tsearch.sql.in
+++ b/contrib/tsearch2/tsearch.sql.in
@@ -14,46 +14,46 @@ CREATE TABLE pg_ts_dict (
 
 --dict interface
 CREATE FUNCTION lexize(oid, text) 
-	returns _text
+	RETURNS _text
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION lexize(text, text)
-        returns _text
+        RETURNS _text
         as 'MODULE_PATHNAME', 'lexize_byname'
-        language 'C'
-        with (isstrict);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION lexize(text)
-        returns _text
+        RETURNS _text
         as 'MODULE_PATHNAME', 'lexize_bycurrent'
-        language 'C'
-        with (isstrict);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION set_curdict(int)
-	returns void
+	RETURNS void
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION set_curdict(text)
-	returns void
+	RETURNS void
 	as 'MODULE_PATHNAME', 'set_curdict_byname'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 --built-in dictionaries
 CREATE FUNCTION dex_init(internal)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME' 
-	language 'C';
+	LANGUAGE C;
 
 CREATE FUNCTION dex_lexize(internal,internal,int4)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 insert into pg_ts_dict select 
 	'simple', 
@@ -64,15 +64,15 @@ insert into pg_ts_dict select
 ;
 	 
 CREATE FUNCTION snb_en_init(internal)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME' 
-	language 'C';
+	LANGUAGE C;
 
 CREATE FUNCTION snb_lexize(internal,internal,int4)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 insert into pg_ts_dict select 
 	'en_stem', 
@@ -83,9 +83,9 @@ insert into pg_ts_dict select
 ;
 
 CREATE FUNCTION snb_ru_init_koi8(internal)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME' 
-	language 'C';
+	LANGUAGE C;
 
 insert into pg_ts_dict select 
 	'ru_stem_koi8', 
@@ -96,9 +96,9 @@ insert into pg_ts_dict select
 ;
 	 
 CREATE FUNCTION snb_ru_init_utf8(internal)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME' 
-	language 'C';
+	LANGUAGE C;
 
 insert into pg_ts_dict select 
 	'ru_stem_utf8', 
@@ -109,15 +109,15 @@ insert into pg_ts_dict select
 ;
 	 
 CREATE FUNCTION spell_init(internal)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME' 
-	language 'C';
+	LANGUAGE C;
 
 CREATE FUNCTION spell_lexize(internal,internal,int4)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 insert into pg_ts_dict select 
 	'ispell_template', 
@@ -128,15 +128,15 @@ insert into pg_ts_dict select
 ;
 
 CREATE FUNCTION syn_init(internal)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME' 
-	language 'C';
+	LANGUAGE C;
 
 CREATE FUNCTION syn_lexize(internal,internal,int4)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 insert into pg_ts_dict select 
 	'synonym', 
@@ -162,81 +162,81 @@ CREATE TYPE tokentype
 	as (tokid int4, alias text, descr text); 
 
 CREATE FUNCTION token_type(int4)
-	returns setof tokentype
+	RETURNS setof tokentype
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION token_type(text)
-	returns setof tokentype
+	RETURNS setof tokentype
 	as 'MODULE_PATHNAME', 'token_type_byname'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION token_type()
-	returns setof tokentype
+	RETURNS setof tokentype
 	as 'MODULE_PATHNAME', 'token_type_current'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION set_curprs(int)
-	returns void
+	RETURNS void
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION set_curprs(text)
-	returns void
+	RETURNS void
 	as 'MODULE_PATHNAME', 'set_curprs_byname'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE tokenout 
 	as (tokid int4, token text);
 
 CREATE FUNCTION parse(oid,text)
-	returns setof tokenout
+	RETURNS setof tokenout
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
  
 CREATE FUNCTION parse(text,text)
-	returns setof tokenout
+	RETURNS setof tokenout
 	as 'MODULE_PATHNAME', 'parse_byname'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
  
 CREATE FUNCTION parse(text)
-	returns setof tokenout
+	RETURNS setof tokenout
 	as 'MODULE_PATHNAME', 'parse_current'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
  
 --default parser
 CREATE FUNCTION prsd_start(internal,int4)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME'
-	language 'C';
+	LANGUAGE C;
 
 CREATE FUNCTION prsd_getlexeme(internal,internal,internal)
-	returns int4
+	RETURNS int4
 	as 'MODULE_PATHNAME'
-	language 'C';
+	LANGUAGE C;
 
 CREATE FUNCTION prsd_end(internal)
-	returns void
+	RETURNS void
 	as 'MODULE_PATHNAME'
-	language 'C';
+	LANGUAGE C;
 
 CREATE FUNCTION prsd_lextype(internal)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME'
-	language 'C';
+	LANGUAGE C;
 
 CREATE FUNCTION prsd_headline(internal,internal,internal)
-	returns internal
+	RETURNS internal
 	as 'MODULE_PATHNAME'
-	language 'C';
+	LANGUAGE C;
 
 insert into pg_ts_parser select
 	'default',
@@ -264,22 +264,22 @@ CREATE TABLE pg_ts_cfgmap (
 ) with oids;
 
 CREATE FUNCTION set_curcfg(int)
-	returns void
+	RETURNS void
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION set_curcfg(text)
-	returns void
+	RETURNS void
 	as 'MODULE_PATHNAME', 'set_curcfg_byname'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION show_curcfg()
-	returns oid
+	RETURNS oid
 	as 'MODULE_PATHNAME'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 insert into pg_ts_cfg values ('default', 'default','C');
 insert into pg_ts_cfg values ('default_russian', 'default','ru_RU.KOI8-R');
@@ -367,12 +367,12 @@ insert into pg_ts_cfgmap values ('simple', 'uint', '{simple}');
 CREATE FUNCTION tsvector_in(cstring)
 RETURNS tsvector
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION tsvector_out(tsvector)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE tsvector (
         INTERNALLENGTH = -1,
@@ -384,37 +384,37 @@ CREATE TYPE tsvector (
 CREATE FUNCTION length(tsvector)
 RETURNS int4
 AS 'MODULE_PATHNAME', 'tsvector_length'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION to_tsvector(oid, text)
 RETURNS tsvector
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION to_tsvector(text, text)
 RETURNS tsvector
 AS 'MODULE_PATHNAME', 'to_tsvector_name'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION to_tsvector(text)
 RETURNS tsvector
 AS 'MODULE_PATHNAME', 'to_tsvector_current'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION strip(tsvector)
 RETURNS tsvector
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION setweight(tsvector,"char")
 RETURNS tsvector
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION concat(tsvector,tsvector)
 RETURNS tsvector
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR || (
         LEFTARG = tsvector,
@@ -426,12 +426,12 @@ CREATE OPERATOR || (
 CREATE FUNCTION tsquery_in(cstring)
 RETURNS tsquery
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION tsquery_out(tsquery)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE tsquery (
         INTERNALLENGTH = -1,
@@ -443,50 +443,50 @@ CREATE TYPE tsquery (
 CREATE FUNCTION querytree(tsquery)
 RETURNS text
 AS 'MODULE_PATHNAME', 'tsquerytree'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION to_tsquery(oid, text)
 RETURNS tsquery
 AS 'MODULE_PATHNAME'
-LANGUAGE 'c' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION to_tsquery(text, text)
 RETURNS tsquery
 AS 'MODULE_PATHNAME','to_tsquery_name'
-LANGUAGE 'c' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION to_tsquery(text)
 RETURNS tsquery
 AS 'MODULE_PATHNAME','to_tsquery_current'
-LANGUAGE 'c' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION plainto_tsquery(oid, text)
 RETURNS tsquery
 AS 'MODULE_PATHNAME'
-LANGUAGE 'c' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION plainto_tsquery(text, text)
 RETURNS tsquery
 AS 'MODULE_PATHNAME','plainto_tsquery_name'
-LANGUAGE 'c' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION plainto_tsquery(text)
 RETURNS tsquery
 AS 'MODULE_PATHNAME','plainto_tsquery_current'
-LANGUAGE 'c' with (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 --operations
 CREATE FUNCTION exectsq(tsvector, tsquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
   
 COMMENT ON FUNCTION exectsq(tsvector, tsquery) IS 'boolean operation with text index';
 
 CREATE FUNCTION rexectsq(tsquery, tsvector)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 COMMENT ON FUNCTION rexectsq(tsquery, tsvector) IS 'boolean operation with text index';
 
@@ -511,90 +511,90 @@ CREATE OPERATOR @@ (
 CREATE FUNCTION tsearch2()
 RETURNS trigger
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 --Relevation
 CREATE FUNCTION rank(float4[], tsvector, tsquery)
 RETURNS float4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION rank(float4[], tsvector, tsquery, int4)
 RETURNS float4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION rank(tsvector, tsquery)
 RETURNS float4
 AS 'MODULE_PATHNAME', 'rank_def'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION rank(tsvector, tsquery, int4)
 RETURNS float4
 AS 'MODULE_PATHNAME', 'rank_def'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION rank_cd(int4, tsvector, tsquery)
 RETURNS float4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION rank_cd(int4, tsvector, tsquery, int4)
 RETURNS float4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION rank_cd(tsvector, tsquery)
 RETURNS float4
 AS 'MODULE_PATHNAME', 'rank_cd_def'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION rank_cd(tsvector, tsquery, int4)
 RETURNS float4
 AS 'MODULE_PATHNAME', 'rank_cd_def'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION headline(oid, text, tsquery, text)
 RETURNS text
 AS 'MODULE_PATHNAME', 'headline'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION headline(oid, text, tsquery)
 RETURNS text
 AS 'MODULE_PATHNAME', 'headline'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION headline(text, text, tsquery, text)
 RETURNS text
 AS 'MODULE_PATHNAME', 'headline_byname'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION headline(text, text, tsquery)
 RETURNS text
 AS 'MODULE_PATHNAME', 'headline_byname'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION headline(text, tsquery, text)
 RETURNS text
 AS 'MODULE_PATHNAME', 'headline_current'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION headline(text, tsquery)
 RETURNS text
 AS 'MODULE_PATHNAME', 'headline_current'
-LANGUAGE 'C' WITH (isstrict, iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 --GiST
 --GiST key type 
 CREATE FUNCTION gtsvector_in(cstring)
 RETURNS gtsvector
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gtsvector_out(gtsvector)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE gtsvector (
         INTERNALLENGTH = -1,
@@ -606,37 +606,37 @@ CREATE TYPE gtsvector (
 CREATE FUNCTION gtsvector_consistent(gtsvector,internal,int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
   
 CREATE FUNCTION gtsvector_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtsvector_decompress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtsvector_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gtsvector_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtsvector_union(internal, internal)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtsvector_same(gtsvector, gtsvector, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 -- CREATE the OPERATOR class
 CREATE OPERATOR CLASS gist_tsvector_ops
@@ -660,12 +660,12 @@ CREATE TYPE statinfo
 --CREATE FUNCTION tsstat_in(cstring)
 --RETURNS tsstat
 --AS 'MODULE_PATHNAME'
---LANGUAGE 'C' with (isstrict);
+--LANGUAGE C RETURNS NULL ON NULL INPUT;
 --
 --CREATE FUNCTION tsstat_out(tsstat)
 --RETURNS cstring
 --AS 'MODULE_PATHNAME'
---LANGUAGE 'C' with (isstrict);
+--LANGUAGE C RETURNS NULL ON NULL INPUT;
 --
 --CREATE TYPE tsstat (
 --        INTERNALLENGTH = -1,
@@ -677,13 +677,13 @@ CREATE TYPE statinfo
 --CREATE FUNCTION ts_accum(tsstat,tsvector)
 --RETURNS tsstat
 --AS 'MODULE_PATHNAME'
---LANGUAGE 'C' with (isstrict);
+--LANGUAGE C RETURNS NULL ON NULL INPUT;
 --
 --CREATE FUNCTION ts_accum_finish(tsstat)
---	returns setof statinfo
+--	RETURNS setof statinfo
 --	as 'MODULE_PATHNAME'
---	language 'C'
---	with (isstrict);
+--	LANGUAGE C
+--	RETURNS NULL ON NULL INPUT;
 --
 --CREATE AGGREGATE stat (
 --	BASETYPE=tsvector,
@@ -694,30 +694,30 @@ CREATE TYPE statinfo
 --); 
 
 CREATE FUNCTION stat(text)
-	returns setof statinfo
+	RETURNS setof statinfo
 	as 'MODULE_PATHNAME', 'ts_stat'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION stat(text,text)
-	returns setof statinfo
+	RETURNS setof statinfo
 	as 'MODULE_PATHNAME', 'ts_stat'
-	language 'C'
-	with (isstrict);
+	LANGUAGE C
+	RETURNS NULL ON NULL INPUT;
 
 --reset - just for debuging
 CREATE FUNCTION reset_tsearch()
-        returns void
+        RETURNS void
         as 'MODULE_PATHNAME'
-        language 'C'
-        with (isstrict);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT;
 
 --get cover (debug for rank_cd)
 CREATE FUNCTION get_covers(tsvector,tsquery)
-        returns text
+        RETURNS text
         as 'MODULE_PATHNAME'
-        language 'C'
-        with (isstrict);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT;
 
 --debug function
 create type tsdebug as (
@@ -729,13 +729,13 @@ create type tsdebug as (
         "tsvector" tsvector
 );
 
-create function _get_parser_from_curcfg() 
-returns text as 
+CREATE FUNCTION _get_parser_from_curcfg() 
+RETURNS text as 
 ' select prs_name from pg_ts_cfg where oid = show_curcfg() '
-language 'SQL' with(isstrict,iscachable);
+LANGUAGE SQL RETURNS NULL ON NULL INPUT IMMUTABLE;
 
-create function ts_debug(text)
-returns setof tsdebug as '
+CREATE FUNCTION ts_debug(text)
+RETURNS setof tsdebug as '
 select 
         m.ts_name,
         t.alias as tok_type,
@@ -753,43 +753,43 @@ where
         t.alias = m.tok_alias and 
         m.ts_name=c.ts_name and 
         c.oid=show_curcfg() 
-' language 'SQL' with(isstrict);
+' LANGUAGE SQL RETURNS NULL ON NULL INPUT;
 
 --compare functions
 CREATE FUNCTION tsvector_cmp(tsvector,tsvector)
 RETURNS int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION tsvector_lt(tsvector,tsvector)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION tsvector_le(tsvector,tsvector)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
         
 CREATE FUNCTION tsvector_eq(tsvector,tsvector)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION tsvector_ge(tsvector,tsvector)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
         
 CREATE FUNCTION tsvector_gt(tsvector,tsvector)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE FUNCTION tsvector_ne(tsvector,tsvector)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR < (
         LEFTARG = tsvector,
@@ -866,37 +866,37 @@ CREATE OPERATOR CLASS tsvector_ops
 CREATE OR REPLACE FUNCTION tsquery_cmp(tsquery,tsquery)
 RETURNS int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION tsquery_lt(tsquery,tsquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION tsquery_le(tsquery,tsquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION tsquery_eq(tsquery,tsquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION tsquery_ge(tsquery,tsquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION tsquery_gt(tsquery,tsquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION tsquery_ne(tsquery,tsquery)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' WITH (isstrict,iscachable);
+LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 
 CREATE OPERATOR < (
@@ -972,16 +972,16 @@ CREATE OPERATOR CLASS tsquery_ops
         FUNCTION        1       tsquery_cmp(tsquery, tsquery);
 
 CREATE OR REPLACE FUNCTION numnode(tsquery)
-        returns int4
+        RETURNS int4
         as 'MODULE_PATHNAME', 'tsquery_numnode'
-        language 'C'
-        with (isstrict,iscachable);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION tsquery_and(tsquery,tsquery)
-        returns tsquery
+        RETURNS tsquery
         as 'MODULE_PATHNAME', 'tsquery_and'
-        language 'C'
-        with (isstrict,iscachable);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR && (
         LEFTARG = tsquery,
@@ -993,10 +993,10 @@ CREATE OPERATOR && (
 );
 
 CREATE OR REPLACE FUNCTION tsquery_or(tsquery,tsquery)
-        returns tsquery
+        RETURNS tsquery
         as 'MODULE_PATHNAME', 'tsquery_or'
-        language 'C'
-        with (isstrict,iscachable);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR || (
         LEFTARG = tsquery,
@@ -1008,10 +1008,10 @@ CREATE OPERATOR || (
 );
 
 CREATE OR REPLACE FUNCTION tsquery_not(tsquery)
-        returns tsquery
+        RETURNS tsquery
         as 'MODULE_PATHNAME', 'tsquery_not'
-        language 'C'
-        with (isstrict,iscachable);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR !! (
         RIGHTARG = tsquery,
@@ -1021,26 +1021,26 @@ CREATE OPERATOR !! (
 --------------rewrite subsystem
 
 CREATE OR REPLACE FUNCTION rewrite(tsquery, text)
-        returns tsquery
+        RETURNS tsquery
         as 'MODULE_PATHNAME', 'tsquery_rewrite'
-        language 'C'
-        with (isstrict,iscachable);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION rewrite(tsquery, tsquery, tsquery)
-        returns tsquery
+        RETURNS tsquery
         as 'MODULE_PATHNAME', 'tsquery_rewrite_query'
-        language 'C'
-        with (isstrict,iscachable);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION rewrite_accum(tsquery,tsquery[])
         RETURNS tsquery
         AS 'MODULE_PATHNAME'
-        LANGUAGE 'C';
+        LANGUAGE C;
 
 CREATE OR REPLACE FUNCTION rewrite_finish(tsquery)
-      returns tsquery
+      RETURNS tsquery
       as 'MODULE_PATHNAME'
-      language 'C';
+      LANGUAGE C;
 
 CREATE AGGREGATE rewrite (
       BASETYPE=tsquery[],
@@ -1050,16 +1050,16 @@ CREATE AGGREGATE rewrite (
 );
 
 CREATE OR REPLACE FUNCTION tsq_mcontains(tsquery, tsquery)
-        returns bool
+        RETURNS bool
         as 'MODULE_PATHNAME'
-        language 'C'
-        with (isstrict,iscachable);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION tsq_mcontained(tsquery, tsquery)
-        returns bool
+        RETURNS bool
         as 'MODULE_PATHNAME'
-        language 'C'
-        with (isstrict,iscachable);
+        LANGUAGE C
+        RETURNS NULL ON NULL INPUT IMMUTABLE;
 
 CREATE OPERATOR @ (
         LEFTARG = tsquery,
@@ -1084,12 +1084,12 @@ CREATE OPERATOR ~ (
 CREATE FUNCTION gtsq_in(cstring)
 RETURNS gtsq
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gtsq_out(gtsq)
 RETURNS cstring
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE TYPE gtsq (
         INTERNALLENGTH = 8,
@@ -1100,37 +1100,37 @@ CREATE TYPE gtsq (
 CREATE FUNCTION gtsq_consistent(gtsq,internal,int4)
 RETURNS bool
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtsq_compress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtsq_decompress(internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtsq_penalty(internal,internal,internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C' with (isstrict);
+LANGUAGE C RETURNS NULL ON NULL INPUT;
 
 CREATE FUNCTION gtsq_picksplit(internal, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtsq_union(bytea, internal)
 RETURNS _int4
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE FUNCTION gtsq_same(gtsq, gtsq, internal)
 RETURNS internal
 AS 'MODULE_PATHNAME'
-LANGUAGE 'C';
+LANGUAGE C;
 
 CREATE OPERATOR CLASS gist_tp_tsquery_ops
 DEFAULT FOR TYPE tsquery USING gist
diff --git a/contrib/xml2/pgxml.sql.in b/contrib/xml2/pgxml.sql.in
index 27bcf527572..006f3f7f53c 100644
--- a/contrib/xml2/pgxml.sql.in
+++ b/contrib/xml2/pgxml.sql.in
@@ -1,32 +1,32 @@
 --SQL for XML parser
 
 CREATE OR REPLACE FUNCTION xml_valid(text) RETURNS bool
-	AS 'MODULE_PATHNAME' LANGUAGE 'c' STRICT IMMUTABLE;
+	AS 'MODULE_PATHNAME' LANGUAGE C STRICT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION xml_encode_special_chars(text) RETURNS text
-	AS 'MODULE_PATHNAME' LANGUAGE 'c' STRICT IMMUTABLE;
+	AS 'MODULE_PATHNAME' LANGUAGE C STRICT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION xpath_string(text,text) RETURNS text
-	AS 'MODULE_PATHNAME' LANGUAGE 'c' STRICT IMMUTABLE;
+	AS 'MODULE_PATHNAME' LANGUAGE C STRICT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION xpath_nodeset(text,text,text,text) RETURNS text
-	AS 'MODULE_PATHNAME' LANGUAGE 'c' STRICT IMMUTABLE;
+	AS 'MODULE_PATHNAME' LANGUAGE C STRICT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION xpath_number(text,text) RETURNS float4
-	AS 'MODULE_PATHNAME' LANGUAGE 'c' STRICT IMMUTABLE;
+	AS 'MODULE_PATHNAME' LANGUAGE C STRICT IMMUTABLE;
 
 CREATE OR REPLACE FUNCTION xpath_bool(text,text) RETURNS boolean
-	AS 'MODULE_PATHNAME' LANGUAGE 'c' STRICT IMMUTABLE;
+	AS 'MODULE_PATHNAME' LANGUAGE C STRICT IMMUTABLE;
 
 -- List function
 
 CREATE OR REPLACE FUNCTION xpath_list(text,text,text) RETURNS text
 	AS 'MODULE_PATHNAME'
-	LANGUAGE 'c' STRICT IMMUTABLE;
+	LANGUAGE C STRICT IMMUTABLE;
 
 
 CREATE OR REPLACE FUNCTION xpath_list(text,text) RETURNS text 
-AS 'SELECT xpath_list($1,$2,'','')' language 'SQL' STRICT IMMUTABLE;
+AS 'SELECT xpath_list($1,$2,'','')' LANGUAGE SQL STRICT IMMUTABLE;
 
 
 
@@ -34,17 +34,17 @@ AS 'SELECT xpath_list($1,$2,'','')' language 'SQL' STRICT IMMUTABLE;
 
 
 CREATE OR REPLACE FUNCTION xpath_nodeset(text,text) RETURNS text AS
-'SELECT xpath_nodeset($1,$2,'''','''')' language 'SQL' STRICT IMMUTABLE;
+'SELECT xpath_nodeset($1,$2,'''','''')' LANGUAGE SQL STRICT IMMUTABLE;
 
 
 CREATE OR REPLACE FUNCTION xpath_nodeset(text,text,text) RETURNS text AS
-'SELECT xpath_nodeset($1,$2,'''',$3)' language 'SQL' STRICT IMMUTABLE;
+'SELECT xpath_nodeset($1,$2,'''',$3)' LANGUAGE SQL STRICT IMMUTABLE;
 
 -- Table function
 
 CREATE OR REPLACE FUNCTION xpath_table(text,text,text,text,text) RETURNS setof record
 	AS 'MODULE_PATHNAME'
-	LANGUAGE 'c' STRICT STABLE;
+	LANGUAGE C STRICT STABLE;
 
 -- XSLT functions
 -- Delete from here to the end of the file if you are not compiling with
@@ -52,9 +52,9 @@ CREATE OR REPLACE FUNCTION xpath_table(text,text,text,text,text) RETURNS setof r
 
 
 CREATE OR REPLACE FUNCTION xslt_process(text,text,text) RETURNS text 
-	AS 'MODULE_PATHNAME' LANGUAGE 'c' STRICT VOLATILE;
+	AS 'MODULE_PATHNAME' LANGUAGE C STRICT VOLATILE;
 
 -- the function checks for the correct argument count
 
 CREATE OR REPLACE FUNCTION xslt_process(text,text) RETURNS text 
-	AS 'MODULE_PATHNAME' LANGUAGE 'c' STRICT IMMUTABLE;
+	AS 'MODULE_PATHNAME' LANGUAGE C STRICT IMMUTABLE;
diff --git a/src/backend/commands/functioncmds.c b/src/backend/commands/functioncmds.c
index 77f892fe501..5814dda31e2 100644
--- a/src/backend/commands/functioncmds.c
+++ b/src/backend/commands/functioncmds.c
@@ -10,7 +10,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/commands/functioncmds.c,v 1.70 2005/11/21 12:49:31 alvherre Exp $
+ *	  $PostgreSQL: pgsql/src/backend/commands/functioncmds.c,v 1.71 2006/02/27 16:09:49 petere Exp $
  *
  * DESCRIPTION
  *	  These routines take the parse tree and pick out the
@@ -632,7 +632,7 @@ CreateFunction(CreateFunctionStmt *stmt)
 		 * In PostgreSQL versions before 6.5, the SQL name of the created
 		 * function could not be different from the internal name, and
 		 * "prosrc" wasn't used.  So there is code out there that does CREATE
-		 * FUNCTION xyz AS '' LANGUAGE 'internal'. To preserve some modicum of
+		 * FUNCTION xyz AS '' LANGUAGE internal. To preserve some modicum of
 		 * backwards compatibility, accept an empty "prosrc" value as meaning
 		 * the supplied SQL function name.
 		 */
diff --git a/src/backend/utils/fmgr/README b/src/backend/utils/fmgr/README
index 235db10ea9b..87044787e8b 100644
--- a/src/backend/utils/fmgr/README
+++ b/src/backend/utils/fmgr/README
@@ -524,7 +524,7 @@ library, depending on whether or not you write a PG_FUNCTION_INFO_V1() for
 each one.
 
 The SQL declaration for a dynamically-loaded function is CREATE FUNCTION
-foo ... LANGUAGE 'C' regardless of whether it is old- or new-style.
+foo ... LANGUAGE C regardless of whether it is old- or new-style.
 
 New-style dynamic functions will be invoked directly by fmgr, and will
 therefore have the same performance as internal functions after the initial
diff --git a/src/backend/utils/mb/conversion_procs/Makefile b/src/backend/utils/mb/conversion_procs/Makefile
index cf07f42560b..6e67f382648 100644
--- a/src/backend/utils/mb/conversion_procs/Makefile
+++ b/src/backend/utils/mb/conversion_procs/Makefile
@@ -4,7 +4,7 @@
 #    Makefile for utils/mb/conversion_procs
 #
 # IDENTIFICATION
-#    $PostgreSQL: pgsql/src/backend/utils/mb/conversion_procs/Makefile,v 1.16 2006/02/18 16:15:22 petere Exp $
+#    $PostgreSQL: pgsql/src/backend/utils/mb/conversion_procs/Makefile,v 1.17 2006/02/27 16:09:49 petere Exp $
 #
 #-------------------------------------------------------------------------
 
@@ -167,7 +167,7 @@ ifeq ($(enable_shared), yes)
 		func=$$1; shift; \
 		obj=$$1; shift; \
 		echo "-- $$se --> $$de"; \
-		echo "CREATE OR REPLACE FUNCTION $$func (INTEGER, INTEGER, CSTRING, INTERNAL, INTEGER) RETURNS VOID AS '$$"libdir"/$$obj', '$$func' LANGUAGE 'c' STRICT;"; \
+		echo "CREATE OR REPLACE FUNCTION $$func (INTEGER, INTEGER, CSTRING, INTERNAL, INTEGER) RETURNS VOID AS '$$"libdir"/$$obj', '$$func' LANGUAGE C STRICT;"; \
 		echo "DROP CONVERSION pg_catalog.$$name;"; \
 		echo "CREATE DEFAULT CONVERSION pg_catalog.$$name FOR '$$se' TO '$$de' FROM $$func;"; \
 	done > $@
diff --git a/src/interfaces/ecpg/test/test_func.pgc b/src/interfaces/ecpg/test/test_func.pgc
index 466512a35b3..12350d220ee 100644
--- a/src/interfaces/ecpg/test/test_func.pgc
+++ b/src/interfaces/ecpg/test/test_func.pgc
@@ -21,7 +21,7 @@ int main(int argc, char* argv[]) {
     	RAISE NOTICE 'TG_NAME=%, TG WHEN=%', TG_NAME, TG_WHEN;
 	RETURN NEW;
     END; $test$
-    LANGUAGE 'plpgsql';
+    LANGUAGE plpgsql;
 
   EXEC SQL CREATE TRIGGER My_Table_Check_Trigger
     BEFORE INSERT
diff --git a/src/pl/plpgsql/src/scan.l b/src/pl/plpgsql/src/scan.l
index e69c8f17b02..0a6c9be20fa 100644
--- a/src/pl/plpgsql/src/scan.l
+++ b/src/pl/plpgsql/src/scan.l
@@ -4,7 +4,7 @@
  *			  procedural language
  *
  * IDENTIFICATION
- *    $PostgreSQL: pgsql/src/pl/plpgsql/src/scan.l,v 1.42 2005/06/26 19:16:07 tgl Exp $
+ *    $PostgreSQL: pgsql/src/pl/plpgsql/src/scan.l,v 1.43 2006/02/27 16:09:50 petere Exp $
  *
  *    This software is copyrighted by Jan Wieck - Hamburg.
  *
@@ -522,7 +522,7 @@ plpgsql_scanner_init(const char *str, int functype)
 	 * Hack: skip any initial newline, so that in the common coding layout
 	 *		CREATE FUNCTION ... AS '
 	 *			code body
-	 *		' LANGUAGE 'plpgsql';
+	 *		' LANGUAGE plpgsql;
 	 * we will think "line 1" is what the programmer thinks of as line 1.
 	 *----------
 	 */
diff --git a/src/pl/tcl/expected/pltcl_setup.out b/src/pl/tcl/expected/pltcl_setup.out
index e168b121b86..0d6d253b63c 100644
--- a/src/pl/tcl/expected/pltcl_setup.out
+++ b/src/pl/tcl/expected/pltcl_setup.out
@@ -52,7 +52,7 @@ create function check_pkey1_exists(int4, bpchar) returns bool as '
         return "t"
     }
     return "f"
-' language 'pltcl';
+' language pltcl;
 --
 -- Trigger function on every change to T_pkey1
 --
@@ -138,7 +138,7 @@ create function trig_pkey1_before() returns trigger as '
     # Anything is fine - let operation pass through
     #
     return OK
-' language 'pltcl';
+' language pltcl;
 create trigger pkey1_before before insert or update or delete on T_pkey1
 	for each row execute procedure
 	trig_pkey1_before();
@@ -175,7 +175,7 @@ create function trig_pkey2_before() returns trigger as '
     # Return modified tuple in NEW
     #
     return [array get NEW]
-' language 'pltcl';
+' language pltcl;
 create trigger pkey2_before before insert or update on T_pkey2
 	for each row execute procedure
 	trig_pkey2_before();
@@ -261,7 +261,7 @@ create function trig_pkey2_after() returns trigger as '
     }
 
     return OK
-' language 'pltcl';
+' language pltcl;
 create trigger pkey2_after after update or delete on T_pkey2
 	for each row execute procedure
 	trig_pkey2_after();
@@ -355,7 +355,7 @@ create function check_primkey() returns trigger as '
     # Anything is fine
     #
     return OK
-' language 'pltcl';
+' language pltcl;
 create trigger dta1_before before insert or update on T_dta1
 	for each row execute procedure
 	check_primkey('ref1', 'ref2', 'T_pkey1', 'key1', 'key2');
@@ -364,7 +364,7 @@ create trigger dta2_before before insert or update on T_dta2
 	check_primkey('ref1', 'ref2', 'T_pkey2', 'key1', 'key2');
 create function tcl_int4add(int4,int4) returns int4 as '
     return [expr $1 + $2]
-' language 'pltcl';
+' language pltcl;
 -- We use split(n) as a quick-and-dirty way of parsing the input array
 -- value, which comes in as a string like '{1,2}'.  There are better ways...
 create function tcl_int4_accum(int4[], int4) returns int4[] as '
@@ -372,12 +372,12 @@ create function tcl_int4_accum(int4[], int4) returns int4[] as '
     set newsum [expr {[lindex $state 1] + $2}]
     set newcnt [expr {[lindex $state 2] + 1}]
     return "{$newsum,$newcnt}"
-' language 'pltcl';
+' language pltcl;
 create function tcl_int4_avg(int4[]) returns int4 as '
     set state [split $1 "{,}"]
     if {[lindex $state 2] == 0} { return_null }
     return [expr {[lindex $state 1] / [lindex $state 2]}]
-' language 'pltcl';
+' language pltcl;
 create aggregate tcl_avg (
 		sfunc = tcl_int4_accum,
 		basetype = int4,
@@ -396,7 +396,7 @@ create function tcl_int4lt(int4,int4) returns bool as '
         return t
     }
     return f
-' language 'pltcl';
+' language pltcl;
 create operator @< (
 		leftarg = int4,
 		rightarg = int4,
diff --git a/src/pl/tcl/sql/pltcl_setup.sql b/src/pl/tcl/sql/pltcl_setup.sql
index 78ddd867eb4..d938f9f4d65 100644
--- a/src/pl/tcl/sql/pltcl_setup.sql
+++ b/src/pl/tcl/sql/pltcl_setup.sql
@@ -58,7 +58,7 @@ create function check_pkey1_exists(int4, bpchar) returns bool as '
         return "t"
     }
     return "f"
-' language 'pltcl';
+' language pltcl;
 
 
 --
@@ -146,7 +146,7 @@ create function trig_pkey1_before() returns trigger as '
     # Anything is fine - let operation pass through
     #
     return OK
-' language 'pltcl';
+' language pltcl;
 
 
 create trigger pkey1_before before insert or update or delete on T_pkey1
@@ -187,7 +187,7 @@ create function trig_pkey2_before() returns trigger as '
     # Return modified tuple in NEW
     #
     return [array get NEW]
-' language 'pltcl';
+' language pltcl;
 
 
 create trigger pkey2_before before insert or update on T_pkey2
@@ -277,7 +277,7 @@ create function trig_pkey2_after() returns trigger as '
     }
 
     return OK
-' language 'pltcl';
+' language pltcl;
 
 
 create trigger pkey2_after after update or delete on T_pkey2
@@ -375,7 +375,7 @@ create function check_primkey() returns trigger as '
     # Anything is fine
     #
     return OK
-' language 'pltcl';
+' language pltcl;
 
 
 create trigger dta1_before before insert or update on T_dta1
@@ -390,7 +390,7 @@ create trigger dta2_before before insert or update on T_dta2
 
 create function tcl_int4add(int4,int4) returns int4 as '
     return [expr $1 + $2]
-' language 'pltcl';
+' language pltcl;
 
 -- We use split(n) as a quick-and-dirty way of parsing the input array
 -- value, which comes in as a string like '{1,2}'.  There are better ways...
@@ -400,13 +400,13 @@ create function tcl_int4_accum(int4[], int4) returns int4[] as '
     set newsum [expr {[lindex $state 1] + $2}]
     set newcnt [expr {[lindex $state 2] + 1}]
     return "{$newsum,$newcnt}"
-' language 'pltcl';
+' language pltcl;
 
 create function tcl_int4_avg(int4[]) returns int4 as '
     set state [split $1 "{,}"]
     if {[lindex $state 2] == 0} { return_null }
     return [expr {[lindex $state 1] / [lindex $state 2]}]
-' language 'pltcl';
+' language pltcl;
 
 create aggregate tcl_avg (
 		sfunc = tcl_int4_accum,
@@ -428,7 +428,7 @@ create function tcl_int4lt(int4,int4) returns bool as '
         return t
     }
     return f
-' language 'pltcl';
+' language pltcl;
 
 create operator @< (
 		leftarg = int4,
diff --git a/src/test/regress/GNUmakefile b/src/test/regress/GNUmakefile
index 5ed7c4ce2d9..7ed01ca629a 100644
--- a/src/test/regress/GNUmakefile
+++ b/src/test/regress/GNUmakefile
@@ -6,7 +6,7 @@
 # Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
 # Portions Copyright (c) 1994, Regents of the University of California
 #
-# $PostgreSQL: pgsql/src/test/regress/GNUmakefile,v 1.55 2005/12/09 21:19:36 petere Exp $
+# $PostgreSQL: pgsql/src/test/regress/GNUmakefile,v 1.56 2006/02/27 16:09:50 petere Exp $
 #
 #-------------------------------------------------------------------------
 
@@ -62,7 +62,7 @@ uninstall:
 	rm -f '$(DESTDIR)$(pgxsdir)/$(subdir)/pg_regress'
 
 
-# Build dynamically-loaded object file for CREATE FUNCTION ... LANGUAGE 'C'.
+# Build dynamically-loaded object file for CREATE FUNCTION ... LANGUAGE C.
 
 NAME = regress
 SO_MAJOR_VERSION= 0
diff --git a/src/test/regress/expected/copy2.out b/src/test/regress/expected/copy2.out
index 99fba57a9e0..7759a411cd8 100644
--- a/src/test/regress/expected/copy2.out
+++ b/src/test/regress/expected/copy2.out
@@ -11,13 +11,13 @@ CREATE FUNCTION fn_x_before () RETURNS TRIGGER AS '
 		NEW.e := ''before trigger fired''::text;
 		return NEW;
 	END;
-' language 'plpgsql';
+' LANGUAGE plpgsql;
 CREATE FUNCTION fn_x_after () RETURNS TRIGGER AS '
   BEGIN
 		UPDATE x set e=''after trigger fired'' where c=''stuff'';
 		return NULL;
 	END;
-' language 'plpgsql';
+' LANGUAGE plpgsql;
 CREATE TRIGGER trg_x_after AFTER INSERT ON x
 FOR EACH ROW EXECUTE PROCEDURE fn_x_after();
 CREATE TRIGGER trg_x_before BEFORE INSERT ON x
diff --git a/src/test/regress/expected/create_type.out b/src/test/regress/expected/create_type.out
index 101382e7392..4e2d44d5c41 100644
--- a/src/test/regress/expected/create_type.out
+++ b/src/test/regress/expected/create_type.out
@@ -18,24 +18,24 @@ CREATE TYPE city_budget (
 CREATE FUNCTION int42_in(cstring)
    RETURNS int42
    AS 'int4in'
-   LANGUAGE 'internal' WITH (isStrict);
+   LANGUAGE internal STRICT;
 NOTICE:  type "int42" is not yet defined
 DETAIL:  Creating a shell type definition.
 CREATE FUNCTION int42_out(int42)
    RETURNS cstring
    AS 'int4out'
-   LANGUAGE 'internal' WITH (isStrict);
+   LANGUAGE internal STRICT;
 NOTICE:  argument type int42 is only a shell
 CREATE FUNCTION text_w_default_in(cstring)
    RETURNS text_w_default
    AS 'textin'
-   LANGUAGE 'internal' WITH (isStrict);
+   LANGUAGE internal STRICT;
 NOTICE:  type "text_w_default" is not yet defined
 DETAIL:  Creating a shell type definition.
 CREATE FUNCTION text_w_default_out(text_w_default)
    RETURNS cstring
    AS 'textout'
-   LANGUAGE 'internal' WITH (isStrict);
+   LANGUAGE internal STRICT;
 NOTICE:  argument type text_w_default is only a shell
 CREATE TYPE int42 (
    internallength = 4,
diff --git a/src/test/regress/expected/plpgsql.out b/src/test/regress/expected/plpgsql.out
index 1a4307dce28..5617b6ef010 100644
--- a/src/test/regress/expected/plpgsql.out
+++ b/src/test/regress/expected/plpgsql.out
@@ -100,7 +100,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 create trigger tg_room_au after update
     on Room for each row execute procedure tg_room_au();
 -- ************************************************************
@@ -112,7 +112,7 @@ begin
     delete from WSlot where roomno = old.roomno;
     return old;
 end;
-' language 'plpgsql';
+' language plpgsql;
 create trigger tg_room_ad after delete
     on Room for each row execute procedure tg_room_ad();
 -- ************************************************************
@@ -140,7 +140,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 create trigger tg_pfield_au after update
     on PField for each row execute procedure tg_pfield_au();
 -- ************************************************************
@@ -152,7 +152,7 @@ begin
     delete from PSlot where pfname = old.name;
     return old;
 end;
-' language 'plpgsql';
+' language plpgsql;
 create trigger tg_pfield_ad after delete
     on PField for each row execute procedure tg_pfield_ad();
 -- ************************************************************
@@ -184,7 +184,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 create trigger tg_system_au after update
     on System for each row execute procedure tg_system_au();
 -- ************************************************************
@@ -237,7 +237,7 @@ begin
 	return old;
     end if;
 end;
-' language 'plpgsql';
+' language plpgsql;
 create trigger tg_hub_a after insert or update or delete
     on Hub for each row execute procedure tg_hub_a();
 -- ************************************************************
@@ -261,7 +261,7 @@ begin
     end loop;
     return 0;
 end
-' language 'plpgsql';
+' language plpgsql;
 -- Test comments
 COMMENT ON FUNCTION tg_hub_adjustslots_wrong(bpchar, integer, integer) IS 'function with args';
 ERROR:  function tg_hub_adjustslots_wrong(character, integer, integer) does not exist
@@ -301,7 +301,7 @@ begin
     new.slotname := sname;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 create trigger tg_hslot_biu before insert or update
     on HSlot for each row execute procedure tg_hslot_biu();
 -- ************************************************************
@@ -321,7 +321,7 @@ begin
     end if;
     raise exception ''no manual manipulation of HSlot'';
 end;
-' language 'plpgsql';
+' language plpgsql;
 create trigger tg_hslot_bd before delete
     on HSlot for each row execute procedure tg_hslot_bd();
 -- ************************************************************
@@ -335,7 +335,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 create trigger tg_chkslotname before insert
     on PSlot for each row execute procedure tg_chkslotname('PS');
 create trigger tg_chkslotname before insert
@@ -357,7 +357,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 create trigger tg_chkslotlink before insert or update
     on PSlot for each row execute procedure tg_chkslotlink();
 create trigger tg_chkslotlink before insert or update
@@ -379,7 +379,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 create trigger tg_chkbacklink before insert or update
     on PSlot for each row execute procedure tg_chkbacklink();
 create trigger tg_chkbacklink before insert or update
@@ -409,7 +409,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 create trigger tg_pslot_bu before update
     on PSlot for each row execute procedure tg_pslot_bu();
 -- ************************************************************
@@ -435,7 +435,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 create trigger tg_wslot_bu before update
     on WSlot for each row execute procedure tg_Wslot_bu();
 -- ************************************************************
@@ -461,7 +461,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 create trigger tg_pline_bu before update
     on PLine for each row execute procedure tg_pline_bu();
 -- ************************************************************
@@ -487,7 +487,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 create trigger tg_iface_bu before update
     on IFace for each row execute procedure tg_iface_bu();
 -- ************************************************************
@@ -513,7 +513,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 create trigger tg_hslot_bu before update
     on HSlot for each row execute procedure tg_hslot_bu();
 -- ************************************************************
@@ -537,7 +537,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 create trigger tg_phone_bu before update
     on PHone for each row execute procedure tg_phone_bu();
 -- ************************************************************
@@ -576,7 +576,7 @@ begin
 	return old;
     end if;
 end;
-' language 'plpgsql';
+' language plpgsql;
 create trigger tg_backlink_a after insert or update or delete
     on PSlot for each row execute procedure tg_backlink_a('PS');
 create trigger tg_backlink_a after insert or update or delete
@@ -636,7 +636,7 @@ begin
     end if;
     raise exception ''illegal backlink beginning with %'', mytype;
 end;
-' language 'plpgsql';
+' language plpgsql;
 -- ************************************************************
 -- * Support function to clear out the backlink field if
 -- * it still points to specific slot
@@ -718,7 +718,7 @@ begin
 	return old;
     end if;
 end;
-' language 'plpgsql';
+' language plpgsql;
 create trigger tg_slotlink_a after insert or update or delete
     on PSlot for each row execute procedure tg_slotlink_a('PS');
 create trigger tg_slotlink_a after insert or update or delete
@@ -812,7 +812,7 @@ begin
     end if;
     raise exception ''illegal slotlink beginning with %'', mytype;
 end;
-' language 'plpgsql';
+' language plpgsql;
 -- ************************************************************
 -- * Support function to clear out the slotlink field if
 -- * it still points to specific slot
@@ -877,7 +877,7 @@ begin
 	return 0;
     end if;
 end;
-' language 'plpgsql';
+' language plpgsql;
 -- ************************************************************
 -- * Describe the backside of a patchfield slot
 -- ************************************************************
@@ -920,7 +920,7 @@ begin
     end if;
     return rec.backlink;
 end;
-' language 'plpgsql';
+' language plpgsql;
 -- ************************************************************
 -- * Describe the front of a patchfield slot
 -- ************************************************************
@@ -954,7 +954,7 @@ begin
     end if;
     return psrec.slotlink;
 end;
-' language 'plpgsql';
+' language plpgsql;
 -- ************************************************************
 -- * Describe the front of a wall connector slot
 -- ************************************************************
@@ -1002,7 +1002,7 @@ begin
     end if;
     return rec.slotlink;
 end;
-' language 'plpgsql';
+' language plpgsql;
 -- ************************************************************
 -- * View of a patchfield describing backside and patches
 -- ************************************************************
@@ -1555,7 +1555,7 @@ BEGIN
         rslt = CAST($1 AS TEXT) || '','' || recursion_test($1 - 1, $2);
     END IF;
     RETURN rslt;
-END;' LANGUAGE 'plpgsql';
+END;' LANGUAGE plpgsql;
 SELECT recursion_test(4,3);
  recursion_test 
 ----------------
@@ -1600,7 +1600,7 @@ create function test_found()
     insert into found_test_tbl values (6);
   end if;
   return true;
-  end;' language 'plpgsql';
+  end;' language plpgsql;
 select test_found();
  test_found 
 ------------
@@ -1629,7 +1629,7 @@ BEGIN
 		RETURN NEXT rec;
 	END LOOP;
 	RETURN;
-END;' language 'plpgsql';
+END;' language plpgsql;
 select * from test_table_func_rec();
   a  
 -----
@@ -1649,7 +1649,7 @@ BEGIN
 		RETURN NEXT row;
 	END LOOP;
 	RETURN;
-END;' language 'plpgsql';
+END;' language plpgsql;
 select * from test_table_func_row();
   a  
 -----
@@ -1669,7 +1669,7 @@ BEGIN
 		RETURN NEXT i + 1;
 	END LOOP;
 	RETURN;
-END;' language 'plpgsql';
+END;' language plpgsql;
 select * from test_ret_set_scalar(1,10);
  test_ret_set_scalar 
 ---------------------
@@ -1699,7 +1699,7 @@ BEGIN
 		RETURN NEXT retval;
 	END IF;
 	RETURN;
-END;' language 'plpgsql';
+END;' language plpgsql;
 SELECT * FROM test_ret_set_rec_dyn(1500) AS (a int, b int, c int);
  a | b  | c  
 ---+----+----
@@ -1725,7 +1725,7 @@ BEGIN
 		SELECT INTO retval 50, 5::numeric, ''xxx''::text;
 		RETURN retval;
 	END IF;
-END;' language 'plpgsql';
+END;' language plpgsql;
 SELECT * FROM test_ret_rec_dyn(1500) AS (a int, b int, c int);
  a | b  | c  
 ---+----+----
@@ -1870,7 +1870,7 @@ BEGIN
 	ELSE
 		RETURN FALSE;
 	END IF;
-END;' language 'plpgsql';
+END;' language plpgsql;
 create function perform_test_func() returns void as '
 BEGIN
 	IF FOUND then
@@ -1890,7 +1890,7 @@ BEGIN
 	END IF;
 
 	RETURN;
-END;' language 'plpgsql';
+END;' language plpgsql;
 SELECT perform_test_func();
  perform_test_func 
 -------------------
@@ -2230,13 +2230,13 @@ begin
     open rc for select a from rc_test;
     return rc;
 end
-$$ language 'plpgsql';
+$$ language plpgsql;
 create function refcursor_test1(refcursor) returns refcursor as $$
 begin
     perform return_refcursor($1);
     return $1;
 end
-$$ language 'plpgsql';
+$$ language plpgsql;
 begin;
 select refcursor_test1('test1');
  refcursor_test1 
@@ -2282,7 +2282,7 @@ begin
         return false;
     end if;
 end
-$$ language 'plpgsql';
+$$ language plpgsql;
 select refcursor_test2(20000, 20000) as "Should be false",
        refcursor_test2(20, 20) as "Should be true";
  Should be false | Should be true 
diff --git a/src/test/regress/expected/polymorphism.out b/src/test/regress/expected/polymorphism.out
index 55687467a0d..57a12583319 100644
--- a/src/test/regress/expected/polymorphism.out
+++ b/src/test/regress/expected/polymorphism.out
@@ -33,29 +33,29 @@
 -- argument polymorphism, but within the constraints of valid aggregate
 -- functions, i.e. tf arg1 and tf return type must match
 -- polymorphic single arg transfn
-CREATE FUNCTION stfp(anyarray) returns anyarray as
-'select $1' language 'sql';
+CREATE FUNCTION stfp(anyarray) RETURNS anyarray AS
+'select $1' LANGUAGE SQL;
 -- non-polymorphic single arg transfn
-CREATE FUNCTION stfnp(int[]) returns int[] as
-'select $1' language 'sql';
+CREATE FUNCTION stfnp(int[]) RETURNS int[] AS
+'select $1' LANGUAGE SQL;
 -- dual polymorphic transfn
-CREATE FUNCTION tfp(anyarray,anyelement) returns anyarray as
-'select $1 || $2' language 'sql';
+CREATE FUNCTION tfp(anyarray,anyelement) RETURNS anyarray AS
+'select $1 || $2' LANGUAGE SQL;
 -- dual non-polymorphic transfn
-CREATE FUNCTION tfnp(int[],int) returns int[] as
-'select $1 || $2' language 'sql';
+CREATE FUNCTION tfnp(int[],int) RETURNS int[] AS
+'select $1 || $2' LANGUAGE SQL;
 -- arg1 only polymorphic transfn
-CREATE FUNCTION tf1p(anyarray,int) returns anyarray as
-'select $1' language 'sql';
+CREATE FUNCTION tf1p(anyarray,int) RETURNS anyarray AS
+'select $1' LANGUAGE SQL;
 -- arg2 only polymorphic transfn
-CREATE FUNCTION tf2p(int[],anyelement) returns int[] as
-'select $1' language 'sql';
+CREATE FUNCTION tf2p(int[],anyelement) RETURNS int[] AS
+'select $1' LANGUAGE SQL;
 -- finalfn polymorphic
-CREATE FUNCTION ffp(anyarray) returns anyarray as
-'select $1' language 'sql';
+CREATE FUNCTION ffp(anyarray) RETURNS anyarray AS
+'select $1' LANGUAGE SQL;
 -- finalfn non-polymorphic
 CREATE FUNCTION ffnp(int[]) returns int[] as
-'select $1' language 'sql';
+'select $1' LANGUAGE SQL;
 -- Try to cover all the possible states:
 -- 
 -- Note: in Cases 1 & 2, we are trying to return P. Therefore, if the transfn
diff --git a/src/test/regress/expected/portals.out b/src/test/regress/expected/portals.out
index cbff0b4245a..ab62ac2705b 100644
--- a/src/test/regress/expected/portals.out
+++ b/src/test/regress/expected/portals.out
@@ -779,7 +779,7 @@ BEGIN;
 CREATE FUNCTION declares_cursor(text)
    RETURNS void
    AS 'DECLARE c CURSOR FOR SELECT stringu1 FROM tenk1 WHERE stringu1 LIKE $1;'
-   LANGUAGE 'sql';
+   LANGUAGE SQL;
 SELECT declares_cursor('AB%');
  declares_cursor 
 -----------------
diff --git a/src/test/regress/expected/rangefuncs.out b/src/test/regress/expected/rangefuncs.out
index 49fc121f04f..000d4e36c52 100644
--- a/src/test/regress/expected/rangefuncs.out
+++ b/src/test/regress/expected/rangefuncs.out
@@ -188,7 +188,7 @@ SELECT * FROM vw_getfoo;
 -- plpgsql, proretset = f, prorettype = b
 DROP VIEW vw_getfoo;
 DROP FUNCTION getfoo(int);
-CREATE FUNCTION getfoo(int) RETURNS int AS 'DECLARE fooint int; BEGIN SELECT fooid into fooint FROM foo WHERE fooid = $1; RETURN fooint; END;' LANGUAGE 'plpgsql';
+CREATE FUNCTION getfoo(int) RETURNS int AS 'DECLARE fooint int; BEGIN SELECT fooid into fooint FROM foo WHERE fooid = $1; RETURN fooint; END;' LANGUAGE plpgsql;
 SELECT * FROM getfoo(1) AS t1;
  t1 
 ----
@@ -205,7 +205,7 @@ SELECT * FROM vw_getfoo;
 -- plpgsql, proretset = f, prorettype = c
 DROP VIEW vw_getfoo;
 DROP FUNCTION getfoo(int);
-CREATE FUNCTION getfoo(int) RETURNS foo AS 'DECLARE footup foo%ROWTYPE; BEGIN SELECT * into footup FROM foo WHERE fooid = $1; RETURN footup; END;' LANGUAGE 'plpgsql';
+CREATE FUNCTION getfoo(int) RETURNS foo AS 'DECLARE footup foo%ROWTYPE; BEGIN SELECT * into footup FROM foo WHERE fooid = $1; RETURN footup; END;' LANGUAGE plpgsql;
 SELECT * FROM getfoo(1) AS t1;
  fooid | foosubid | fooname 
 -------+----------+---------
diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index 90e38d013f3..7d38d3e8bbc 100644
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -764,7 +764,7 @@ create view rtest_vview4 as select X.a, X.b, count(Y.a) as refcount
 	group by X.a, X.b;
 create function rtest_viewfunc1(int4) returns int4 as
 	'select count(*)::int4 from rtest_view2 where a = $1'
-	language 'sql';
+	language sql;
 create view rtest_vview5 as select a, b, rtest_viewfunc1(a) as refcount
 	from rtest_view1;
 insert into rtest_view1 values (1, 'item 1', 't');
diff --git a/src/test/regress/expected/triggers.out b/src/test/regress/expected/triggers.out
index 9d6692f35c5..e91c5a36320 100644
--- a/src/test/regress/expected/triggers.out
+++ b/src/test/regress/expected/triggers.out
@@ -276,7 +276,7 @@ drop sequence ttdummy_seq;
 CREATE TABLE log_table (tstamp timestamp default timeofday()::timestamp);
 CREATE TABLE main_table (a int, b int);
 COPY main_table (a,b) FROM stdin;
-CREATE FUNCTION trigger_func() RETURNS trigger LANGUAGE 'plpgsql' AS '
+CREATE FUNCTION trigger_func() RETURNS trigger LANGUAGE plpgsql AS '
 BEGIN
 	RAISE NOTICE ''trigger_func() called: action = %, when = %, level = %'', TG_OP, TG_WHEN, TG_LEVEL;
 	RETURN NULL;
diff --git a/src/test/regress/input/create_function_1.source b/src/test/regress/input/create_function_1.source
index faa73156dc2..fb357d93b07 100644
--- a/src/test/regress/input/create_function_1.source
+++ b/src/test/regress/input/create_function_1.source
@@ -5,74 +5,74 @@
 CREATE FUNCTION widget_in(cstring)
    RETURNS widget
    AS '@abs_builddir@/regress@DLSUFFIX@'
-   LANGUAGE 'C' STRICT;
+   LANGUAGE C STRICT;
 
 CREATE FUNCTION widget_out(widget)
    RETURNS cstring
    AS '@abs_builddir@/regress@DLSUFFIX@'
-   LANGUAGE 'C' STRICT;
+   LANGUAGE C STRICT;
 
 CREATE FUNCTION int44in(cstring)
    RETURNS city_budget
    AS '@abs_builddir@/regress@DLSUFFIX@'
-   LANGUAGE 'C' STRICT;
+   LANGUAGE C STRICT;
 
 CREATE FUNCTION int44out(city_budget)
    RETURNS cstring
    AS '@abs_builddir@/regress@DLSUFFIX@'
-   LANGUAGE 'C' STRICT;
+   LANGUAGE C STRICT;
 
 CREATE FUNCTION check_primary_key ()
 	RETURNS trigger
 	AS '@abs_builddir@/../../../contrib/spi/refint@DLSUFFIX@'
-	LANGUAGE 'C';
+	LANGUAGE C;
 
 CREATE FUNCTION check_foreign_key ()
 	RETURNS trigger
 	AS '@abs_builddir@/../../../contrib/spi/refint@DLSUFFIX@'
-	LANGUAGE 'C';
+	LANGUAGE C;
 
 CREATE FUNCTION autoinc ()
 	RETURNS trigger
 	AS '@abs_builddir@/../../../contrib/spi/autoinc@DLSUFFIX@'
-	LANGUAGE 'C';
+	LANGUAGE C;
 
 CREATE FUNCTION funny_dup17 ()
         RETURNS trigger
         AS '@abs_builddir@/regress@DLSUFFIX@'
-        LANGUAGE 'C';
+        LANGUAGE C;
 
 CREATE FUNCTION ttdummy ()
         RETURNS trigger
         AS '@abs_builddir@/regress@DLSUFFIX@'
-        LANGUAGE 'C';
+        LANGUAGE C;
 
 CREATE FUNCTION set_ttdummy (int4)
         RETURNS int4
         AS '@abs_builddir@/regress@DLSUFFIX@'
-        LANGUAGE 'C' STRICT;
+        LANGUAGE C STRICT;
 
 -- Things that shouldn't work:
 
-CREATE FUNCTION test1 (int) RETURNS int LANGUAGE sql
+CREATE FUNCTION test1 (int) RETURNS int LANGUAGE SQL
     AS 'SELECT ''not an integer'';';
 
-CREATE FUNCTION test1 (int) RETURNS int LANGUAGE sql
+CREATE FUNCTION test1 (int) RETURNS int LANGUAGE SQL
     AS 'not even SQL';
 
-CREATE FUNCTION test1 (int) RETURNS int LANGUAGE sql
+CREATE FUNCTION test1 (int) RETURNS int LANGUAGE SQL
     AS 'SELECT 1, 2, 3;';
 
-CREATE FUNCTION test1 (int) RETURNS int LANGUAGE sql
+CREATE FUNCTION test1 (int) RETURNS int LANGUAGE SQL
     AS 'SELECT $2;';
 
-CREATE FUNCTION test1 (int) RETURNS int LANGUAGE sql
+CREATE FUNCTION test1 (int) RETURNS int LANGUAGE SQL
     AS 'a', 'b';
 
-CREATE FUNCTION test1 (int) RETURNS int LANGUAGE c
+CREATE FUNCTION test1 (int) RETURNS int LANGUAGE C
     AS 'nosuchfile';
 
-CREATE FUNCTION test1 (int) RETURNS int LANGUAGE c
+CREATE FUNCTION test1 (int) RETURNS int LANGUAGE C
     AS '@abs_builddir@/regress@DLSUFFIX@', 'nosuchsymbol';
 
 CREATE FUNCTION test1 (int) RETURNS int LANGUAGE internal
diff --git a/src/test/regress/input/create_function_2.source b/src/test/regress/input/create_function_2.source
index 07d26c1d8f5..98ecfe855f8 100644
--- a/src/test/regress/input/create_function_2.source
+++ b/src/test/regress/input/create_function_2.source
@@ -4,25 +4,25 @@
 CREATE FUNCTION hobbies(person)
    RETURNS setof hobbies_r 
    AS 'select * from hobbies_r where person = $1.name'
-   LANGUAGE 'sql';
+   LANGUAGE SQL;
 
 
 CREATE FUNCTION hobby_construct(text, text)
    RETURNS hobbies_r
    AS 'select $1 as name, $2 as hobby'
-   LANGUAGE 'sql';
+   LANGUAGE SQL;
 
 
 CREATE FUNCTION hobbies_by_name(hobbies_r.name%TYPE)
    RETURNS hobbies_r.person%TYPE
    AS 'select person from hobbies_r where name = $1'
-   LANGUAGE 'sql';
+   LANGUAGE SQL;
 
 
 CREATE FUNCTION equipment(hobbies_r)
    RETURNS setof equipment_r
    AS 'select * from equipment_r where hobby = $1.name'
-   LANGUAGE 'sql';
+   LANGUAGE SQL;
 
 
 CREATE FUNCTION user_relns()
@@ -32,37 +32,37 @@ CREATE FUNCTION user_relns()
        where relnamespace = n.oid and
              (nspname !~ ''pg_.*'' and nspname <> ''information_schema'') and
              relkind <> ''i'' '
-   LANGUAGE 'sql';
+   LANGUAGE SQL;
 
 CREATE FUNCTION pt_in_widget(point, widget)
    RETURNS bool
    AS '@abs_builddir@/regress@DLSUFFIX@'
-   LANGUAGE 'C';
+   LANGUAGE C;
 
 CREATE FUNCTION overpaid(emp)
    RETURNS bool
    AS '@abs_builddir@/regress@DLSUFFIX@'
-   LANGUAGE 'C';
+   LANGUAGE C;
 
 CREATE FUNCTION boxarea(box)
    RETURNS float8
    AS '@abs_builddir@/regress@DLSUFFIX@'
-   LANGUAGE 'C';
+   LANGUAGE C;
 
 CREATE FUNCTION interpt_pp(path, path)
    RETURNS point
    AS '@abs_builddir@/regress@DLSUFFIX@'
-   LANGUAGE 'C';
+   LANGUAGE C;
 
 CREATE FUNCTION reverse_name(name)
    RETURNS name
    AS '@abs_builddir@/regress@DLSUFFIX@'
-   LANGUAGE 'c';
+   LANGUAGE C;
 
 CREATE FUNCTION oldstyle_length(int4, text)
    RETURNS int4
    AS '@abs_builddir@/regress@DLSUFFIX@'
-   LANGUAGE 'c';
+   LANGUAGE C;
 
 --
 -- Function dynamic loading
diff --git a/src/test/regress/output/create_function_1.source b/src/test/regress/output/create_function_1.source
index ed275b1f482..a3c506598f6 100644
--- a/src/test/regress/output/create_function_1.source
+++ b/src/test/regress/output/create_function_1.source
@@ -4,76 +4,76 @@
 CREATE FUNCTION widget_in(cstring)
    RETURNS widget
    AS '@abs_builddir@/regress@DLSUFFIX@'
-   LANGUAGE 'C' STRICT;
+   LANGUAGE C STRICT;
 NOTICE:  type "widget" is not yet defined
 DETAIL:  Creating a shell type definition.
 CREATE FUNCTION widget_out(widget)
    RETURNS cstring
    AS '@abs_builddir@/regress@DLSUFFIX@'
-   LANGUAGE 'C' STRICT;
+   LANGUAGE C STRICT;
 NOTICE:  argument type widget is only a shell
 CREATE FUNCTION int44in(cstring)
    RETURNS city_budget
    AS '@abs_builddir@/regress@DLSUFFIX@'
-   LANGUAGE 'C' STRICT;
+   LANGUAGE C STRICT;
 NOTICE:  type "city_budget" is not yet defined
 DETAIL:  Creating a shell type definition.
 CREATE FUNCTION int44out(city_budget)
    RETURNS cstring
    AS '@abs_builddir@/regress@DLSUFFIX@'
-   LANGUAGE 'C' STRICT;
+   LANGUAGE C STRICT;
 NOTICE:  argument type city_budget is only a shell
 CREATE FUNCTION check_primary_key ()
 	RETURNS trigger
 	AS '@abs_builddir@/../../../contrib/spi/refint@DLSUFFIX@'
-	LANGUAGE 'C';
+	LANGUAGE C;
 CREATE FUNCTION check_foreign_key ()
 	RETURNS trigger
 	AS '@abs_builddir@/../../../contrib/spi/refint@DLSUFFIX@'
-	LANGUAGE 'C';
+	LANGUAGE C;
 CREATE FUNCTION autoinc ()
 	RETURNS trigger
 	AS '@abs_builddir@/../../../contrib/spi/autoinc@DLSUFFIX@'
-	LANGUAGE 'C';
+	LANGUAGE C;
 CREATE FUNCTION funny_dup17 ()
         RETURNS trigger
         AS '@abs_builddir@/regress@DLSUFFIX@'
-        LANGUAGE 'C';
+        LANGUAGE C;
 CREATE FUNCTION ttdummy ()
         RETURNS trigger
         AS '@abs_builddir@/regress@DLSUFFIX@'
-        LANGUAGE 'C';
+        LANGUAGE C;
 CREATE FUNCTION set_ttdummy (int4)
         RETURNS int4
         AS '@abs_builddir@/regress@DLSUFFIX@'
-        LANGUAGE 'C' STRICT;
+        LANGUAGE C STRICT;
 -- Things that shouldn't work:
-CREATE FUNCTION test1 (int) RETURNS int LANGUAGE sql
+CREATE FUNCTION test1 (int) RETURNS int LANGUAGE SQL
     AS 'SELECT ''not an integer'';';
 ERROR:  return type mismatch in function declared to return integer
 DETAIL:  Actual return type is "unknown".
 CONTEXT:  SQL function "test1"
-CREATE FUNCTION test1 (int) RETURNS int LANGUAGE sql
+CREATE FUNCTION test1 (int) RETURNS int LANGUAGE SQL
     AS 'not even SQL';
 ERROR:  syntax error at or near "not" at character 62
 LINE 2:     AS 'not even SQL';
                 ^
-CREATE FUNCTION test1 (int) RETURNS int LANGUAGE sql
+CREATE FUNCTION test1 (int) RETURNS int LANGUAGE SQL
     AS 'SELECT 1, 2, 3;';
 ERROR:  return type mismatch in function declared to return integer
 DETAIL:  Final SELECT must return exactly one column.
 CONTEXT:  SQL function "test1"
-CREATE FUNCTION test1 (int) RETURNS int LANGUAGE sql
+CREATE FUNCTION test1 (int) RETURNS int LANGUAGE SQL
     AS 'SELECT $2;';
 ERROR:  there is no parameter $2
 CONTEXT:  SQL function "test1"
-CREATE FUNCTION test1 (int) RETURNS int LANGUAGE sql
+CREATE FUNCTION test1 (int) RETURNS int LANGUAGE SQL
     AS 'a', 'b';
 ERROR:  only one AS item needed for language "sql"
-CREATE FUNCTION test1 (int) RETURNS int LANGUAGE c
+CREATE FUNCTION test1 (int) RETURNS int LANGUAGE C
     AS 'nosuchfile';
 ERROR:  could not access file "nosuchfile": No such file or directory
-CREATE FUNCTION test1 (int) RETURNS int LANGUAGE c
+CREATE FUNCTION test1 (int) RETURNS int LANGUAGE C
     AS '@abs_builddir@/regress@DLSUFFIX@', 'nosuchsymbol';
 ERROR:  could not find function "nosuchsymbol" in file "@abs_builddir@/regress@DLSUFFIX@"
 CREATE FUNCTION test1 (int) RETURNS int LANGUAGE internal
diff --git a/src/test/regress/output/create_function_2.source b/src/test/regress/output/create_function_2.source
index dd308261d9f..57802a4f7e5 100644
--- a/src/test/regress/output/create_function_2.source
+++ b/src/test/regress/output/create_function_2.source
@@ -4,21 +4,21 @@
 CREATE FUNCTION hobbies(person)
    RETURNS setof hobbies_r 
    AS 'select * from hobbies_r where person = $1.name'
-   LANGUAGE 'sql';
+   LANGUAGE SQL;
 CREATE FUNCTION hobby_construct(text, text)
    RETURNS hobbies_r
    AS 'select $1 as name, $2 as hobby'
-   LANGUAGE 'sql';
+   LANGUAGE SQL;
 CREATE FUNCTION hobbies_by_name(hobbies_r.name%TYPE)
    RETURNS hobbies_r.person%TYPE
    AS 'select person from hobbies_r where name = $1'
-   LANGUAGE 'sql';
+   LANGUAGE SQL;
 NOTICE:  type reference hobbies_r.name%TYPE converted to text
 NOTICE:  type reference hobbies_r.person%TYPE converted to text
 CREATE FUNCTION equipment(hobbies_r)
    RETURNS setof equipment_r
    AS 'select * from equipment_r where hobby = $1.name'
-   LANGUAGE 'sql';
+   LANGUAGE SQL;
 CREATE FUNCTION user_relns()
    RETURNS setof name
    AS 'select relname 
@@ -26,31 +26,31 @@ CREATE FUNCTION user_relns()
        where relnamespace = n.oid and
              (nspname !~ ''pg_.*'' and nspname <> ''information_schema'') and
              relkind <> ''i'' '
-   LANGUAGE 'sql';
+   LANGUAGE SQL;
 CREATE FUNCTION pt_in_widget(point, widget)
    RETURNS bool
    AS '@abs_builddir@/regress@DLSUFFIX@'
-   LANGUAGE 'C';
+   LANGUAGE C;
 CREATE FUNCTION overpaid(emp)
    RETURNS bool
    AS '@abs_builddir@/regress@DLSUFFIX@'
-   LANGUAGE 'C';
+   LANGUAGE C;
 CREATE FUNCTION boxarea(box)
    RETURNS float8
    AS '@abs_builddir@/regress@DLSUFFIX@'
-   LANGUAGE 'C';
+   LANGUAGE C;
 CREATE FUNCTION interpt_pp(path, path)
    RETURNS point
    AS '@abs_builddir@/regress@DLSUFFIX@'
-   LANGUAGE 'C';
+   LANGUAGE C;
 CREATE FUNCTION reverse_name(name)
    RETURNS name
    AS '@abs_builddir@/regress@DLSUFFIX@'
-   LANGUAGE 'c';
+   LANGUAGE C;
 CREATE FUNCTION oldstyle_length(int4, text)
    RETURNS int4
    AS '@abs_builddir@/regress@DLSUFFIX@'
-   LANGUAGE 'c';
+   LANGUAGE C;
 --
 -- Function dynamic loading
 --
diff --git a/src/test/regress/sql/copy2.sql b/src/test/regress/sql/copy2.sql
index 5d73256c122..b193388ab8c 100644
--- a/src/test/regress/sql/copy2.sql
+++ b/src/test/regress/sql/copy2.sql
@@ -11,14 +11,14 @@ CREATE FUNCTION fn_x_before () RETURNS TRIGGER AS '
 		NEW.e := ''before trigger fired''::text;
 		return NEW;
 	END;
-' language 'plpgsql';
+' LANGUAGE plpgsql;
 
 CREATE FUNCTION fn_x_after () RETURNS TRIGGER AS '
   BEGIN
 		UPDATE x set e=''after trigger fired'' where c=''stuff'';
 		return NULL;
 	END;
-' language 'plpgsql';
+' LANGUAGE plpgsql;
 
 CREATE TRIGGER trg_x_after AFTER INSERT ON x
 FOR EACH ROW EXECUTE PROCEDURE fn_x_after();
diff --git a/src/test/regress/sql/create_type.sql b/src/test/regress/sql/create_type.sql
index 6e8fa84b7dc..66d78c9216b 100644
--- a/src/test/regress/sql/create_type.sql
+++ b/src/test/regress/sql/create_type.sql
@@ -22,19 +22,19 @@ CREATE TYPE city_budget (
 CREATE FUNCTION int42_in(cstring)
    RETURNS int42
    AS 'int4in'
-   LANGUAGE 'internal' WITH (isStrict);
+   LANGUAGE internal STRICT;
 CREATE FUNCTION int42_out(int42)
    RETURNS cstring
    AS 'int4out'
-   LANGUAGE 'internal' WITH (isStrict);
+   LANGUAGE internal STRICT;
 CREATE FUNCTION text_w_default_in(cstring)
    RETURNS text_w_default
    AS 'textin'
-   LANGUAGE 'internal' WITH (isStrict);
+   LANGUAGE internal STRICT;
 CREATE FUNCTION text_w_default_out(text_w_default)
    RETURNS cstring
    AS 'textout'
-   LANGUAGE 'internal' WITH (isStrict);
+   LANGUAGE internal STRICT;
 
 CREATE TYPE int42 (
    internallength = 4,
diff --git a/src/test/regress/sql/plpgsql.sql b/src/test/regress/sql/plpgsql.sql
index 5e8db475720..a2d65817b1f 100644
--- a/src/test/regress/sql/plpgsql.sql
+++ b/src/test/regress/sql/plpgsql.sql
@@ -134,7 +134,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 create trigger tg_room_au after update
     on Room for each row execute procedure tg_room_au();
@@ -149,7 +149,7 @@ begin
     delete from WSlot where roomno = old.roomno;
     return old;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 create trigger tg_room_ad after delete
     on Room for each row execute procedure tg_room_ad();
@@ -183,7 +183,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 create trigger tg_pfield_au after update
     on PField for each row execute procedure tg_pfield_au();
@@ -198,7 +198,7 @@ begin
     delete from PSlot where pfname = old.name;
     return old;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 create trigger tg_pfield_ad after delete
     on PField for each row execute procedure tg_pfield_ad();
@@ -236,7 +236,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 create trigger tg_system_au after update
     on System for each row execute procedure tg_system_au();
@@ -295,7 +295,7 @@ begin
 	return old;
     end if;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 create trigger tg_hub_a after insert or update or delete
     on Hub for each row execute procedure tg_hub_a();
@@ -322,7 +322,7 @@ begin
     end loop;
     return 0;
 end
-' language 'plpgsql';
+' language plpgsql;
 
 -- Test comments
 COMMENT ON FUNCTION tg_hub_adjustslots_wrong(bpchar, integer, integer) IS 'function with args';
@@ -363,7 +363,7 @@ begin
     new.slotname := sname;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 create trigger tg_hslot_biu before insert or update
     on HSlot for each row execute procedure tg_hslot_biu();
@@ -386,7 +386,7 @@ begin
     end if;
     raise exception ''no manual manipulation of HSlot'';
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 create trigger tg_hslot_bd before delete
     on HSlot for each row execute procedure tg_hslot_bd();
@@ -403,7 +403,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 create trigger tg_chkslotname before insert
     on PSlot for each row execute procedure tg_chkslotname('PS');
@@ -432,7 +432,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 create trigger tg_chkslotlink before insert or update
     on PSlot for each row execute procedure tg_chkslotlink();
@@ -461,7 +461,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 create trigger tg_chkbacklink before insert or update
     on PSlot for each row execute procedure tg_chkbacklink();
@@ -496,7 +496,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 create trigger tg_pslot_bu before update
     on PSlot for each row execute procedure tg_pslot_bu();
@@ -525,7 +525,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 create trigger tg_wslot_bu before update
     on WSlot for each row execute procedure tg_Wslot_bu();
@@ -554,7 +554,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 create trigger tg_pline_bu before update
     on PLine for each row execute procedure tg_pline_bu();
@@ -583,7 +583,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 create trigger tg_iface_bu before update
     on IFace for each row execute procedure tg_iface_bu();
@@ -612,7 +612,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 create trigger tg_hslot_bu before update
     on HSlot for each row execute procedure tg_hslot_bu();
@@ -639,7 +639,7 @@ begin
     end if;
     return new;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 create trigger tg_phone_bu before update
     on PHone for each row execute procedure tg_phone_bu();
@@ -681,7 +681,7 @@ begin
 	return old;
     end if;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 
 create trigger tg_backlink_a after insert or update or delete
@@ -747,7 +747,7 @@ begin
     end if;
     raise exception ''illegal backlink beginning with %'', mytype;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 
 -- ************************************************************
@@ -833,7 +833,7 @@ begin
 	return old;
     end if;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 
 create trigger tg_slotlink_a after insert or update or delete
@@ -935,7 +935,7 @@ begin
     end if;
     raise exception ''illegal slotlink beginning with %'', mytype;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 
 -- ************************************************************
@@ -1002,7 +1002,7 @@ begin
 	return 0;
     end if;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 
 -- ************************************************************
@@ -1047,7 +1047,7 @@ begin
     end if;
     return rec.backlink;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 
 -- ************************************************************
@@ -1083,7 +1083,7 @@ begin
     end if;
     return psrec.slotlink;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 
 -- ************************************************************
@@ -1133,7 +1133,7 @@ begin
     end if;
     return rec.slotlink;
 end;
-' language 'plpgsql';
+' language plpgsql;
 
 
 
@@ -1437,7 +1437,7 @@ BEGIN
         rslt = CAST($1 AS TEXT) || '','' || recursion_test($1 - 1, $2);
     END IF;
     RETURN rslt;
-END;' LANGUAGE 'plpgsql';
+END;' LANGUAGE plpgsql;
 
 SELECT recursion_test(4,3);
 
@@ -1480,7 +1480,7 @@ create function test_found()
     insert into found_test_tbl values (6);
   end if;
   return true;
-  end;' language 'plpgsql';
+  end;' language plpgsql;
 
 select test_found();
 select * from found_test_tbl;
@@ -1497,7 +1497,7 @@ BEGIN
 		RETURN NEXT rec;
 	END LOOP;
 	RETURN;
-END;' language 'plpgsql';
+END;' language plpgsql;
 
 select * from test_table_func_rec();
 
@@ -1509,7 +1509,7 @@ BEGIN
 		RETURN NEXT row;
 	END LOOP;
 	RETURN;
-END;' language 'plpgsql';
+END;' language plpgsql;
 
 select * from test_table_func_row();
 
@@ -1521,7 +1521,7 @@ BEGIN
 		RETURN NEXT i + 1;
 	END LOOP;
 	RETURN;
-END;' language 'plpgsql';
+END;' language plpgsql;
 
 select * from test_ret_set_scalar(1,10);
 
@@ -1539,7 +1539,7 @@ BEGIN
 		RETURN NEXT retval;
 	END IF;
 	RETURN;
-END;' language 'plpgsql';
+END;' language plpgsql;
 
 SELECT * FROM test_ret_set_rec_dyn(1500) AS (a int, b int, c int);
 SELECT * FROM test_ret_set_rec_dyn(5) AS (a int, b numeric, c text);
@@ -1555,7 +1555,7 @@ BEGIN
 		SELECT INTO retval 50, 5::numeric, ''xxx''::text;
 		RETURN retval;
 	END IF;
-END;' language 'plpgsql';
+END;' language plpgsql;
 
 SELECT * FROM test_ret_rec_dyn(1500) AS (a int, b int, c int);
 SELECT * FROM test_ret_rec_dyn(5) AS (a int, b numeric, c text);
@@ -1658,7 +1658,7 @@ BEGIN
 	ELSE
 		RETURN FALSE;
 	END IF;
-END;' language 'plpgsql';
+END;' language plpgsql;
 
 create function perform_test_func() returns void as '
 BEGIN
@@ -1679,7 +1679,7 @@ BEGIN
 	END IF;
 
 	RETURN;
-END;' language 'plpgsql';
+END;' language plpgsql;
 
 SELECT perform_test_func();
 SELECT * FROM perform_test;
@@ -1904,14 +1904,14 @@ begin
     open rc for select a from rc_test;
     return rc;
 end
-$$ language 'plpgsql';
+$$ language plpgsql;
 
 create function refcursor_test1(refcursor) returns refcursor as $$
 begin
     perform return_refcursor($1);
     return $1;
 end
-$$ language 'plpgsql';
+$$ language plpgsql;
 
 begin;
 
@@ -1940,7 +1940,7 @@ begin
         return false;
     end if;
 end
-$$ language 'plpgsql';
+$$ language plpgsql;
 
 select refcursor_test2(20000, 20000) as "Should be false",
        refcursor_test2(20, 20) as "Should be true";
diff --git a/src/test/regress/sql/polymorphism.sql b/src/test/regress/sql/polymorphism.sql
index 5175f9f93d1..13d691a9e80 100644
--- a/src/test/regress/sql/polymorphism.sql
+++ b/src/test/regress/sql/polymorphism.sql
@@ -37,32 +37,32 @@
 -- functions, i.e. tf arg1 and tf return type must match
 
 -- polymorphic single arg transfn
-CREATE FUNCTION stfp(anyarray) returns anyarray as
-'select $1' language 'sql';
+CREATE FUNCTION stfp(anyarray) RETURNS anyarray AS
+'select $1' LANGUAGE SQL;
 -- non-polymorphic single arg transfn
-CREATE FUNCTION stfnp(int[]) returns int[] as
-'select $1' language 'sql';
+CREATE FUNCTION stfnp(int[]) RETURNS int[] AS
+'select $1' LANGUAGE SQL;
 
 -- dual polymorphic transfn
-CREATE FUNCTION tfp(anyarray,anyelement) returns anyarray as
-'select $1 || $2' language 'sql';
+CREATE FUNCTION tfp(anyarray,anyelement) RETURNS anyarray AS
+'select $1 || $2' LANGUAGE SQL;
 -- dual non-polymorphic transfn
-CREATE FUNCTION tfnp(int[],int) returns int[] as
-'select $1 || $2' language 'sql';
+CREATE FUNCTION tfnp(int[],int) RETURNS int[] AS
+'select $1 || $2' LANGUAGE SQL;
 
 -- arg1 only polymorphic transfn
-CREATE FUNCTION tf1p(anyarray,int) returns anyarray as
-'select $1' language 'sql';
+CREATE FUNCTION tf1p(anyarray,int) RETURNS anyarray AS
+'select $1' LANGUAGE SQL;
 -- arg2 only polymorphic transfn
-CREATE FUNCTION tf2p(int[],anyelement) returns int[] as
-'select $1' language 'sql';
+CREATE FUNCTION tf2p(int[],anyelement) RETURNS int[] AS
+'select $1' LANGUAGE SQL;
 
 -- finalfn polymorphic
-CREATE FUNCTION ffp(anyarray) returns anyarray as
-'select $1' language 'sql';
+CREATE FUNCTION ffp(anyarray) RETURNS anyarray AS
+'select $1' LANGUAGE SQL;
 -- finalfn non-polymorphic
 CREATE FUNCTION ffnp(int[]) returns int[] as
-'select $1' language 'sql';
+'select $1' LANGUAGE SQL;
 
 -- Try to cover all the possible states:
 -- 
diff --git a/src/test/regress/sql/portals.sql b/src/test/regress/sql/portals.sql
index c0307874e80..43cbf05a90d 100644
--- a/src/test/regress/sql/portals.sql
+++ b/src/test/regress/sql/portals.sql
@@ -239,7 +239,7 @@ BEGIN;
 CREATE FUNCTION declares_cursor(text)
    RETURNS void
    AS 'DECLARE c CURSOR FOR SELECT stringu1 FROM tenk1 WHERE stringu1 LIKE $1;'
-   LANGUAGE 'sql';
+   LANGUAGE SQL;
 
 SELECT declares_cursor('AB%');
 
diff --git a/src/test/regress/sql/rangefuncs.sql b/src/test/regress/sql/rangefuncs.sql
index 50495897acd..c56e35ded4e 100644
--- a/src/test/regress/sql/rangefuncs.sql
+++ b/src/test/regress/sql/rangefuncs.sql
@@ -86,7 +86,7 @@ SELECT * FROM vw_getfoo;
 -- plpgsql, proretset = f, prorettype = b
 DROP VIEW vw_getfoo;
 DROP FUNCTION getfoo(int);
-CREATE FUNCTION getfoo(int) RETURNS int AS 'DECLARE fooint int; BEGIN SELECT fooid into fooint FROM foo WHERE fooid = $1; RETURN fooint; END;' LANGUAGE 'plpgsql';
+CREATE FUNCTION getfoo(int) RETURNS int AS 'DECLARE fooint int; BEGIN SELECT fooid into fooint FROM foo WHERE fooid = $1; RETURN fooint; END;' LANGUAGE plpgsql;
 SELECT * FROM getfoo(1) AS t1;
 CREATE VIEW vw_getfoo AS SELECT * FROM getfoo(1);
 SELECT * FROM vw_getfoo;
@@ -94,7 +94,7 @@ SELECT * FROM vw_getfoo;
 -- plpgsql, proretset = f, prorettype = c
 DROP VIEW vw_getfoo;
 DROP FUNCTION getfoo(int);
-CREATE FUNCTION getfoo(int) RETURNS foo AS 'DECLARE footup foo%ROWTYPE; BEGIN SELECT * into footup FROM foo WHERE fooid = $1; RETURN footup; END;' LANGUAGE 'plpgsql';
+CREATE FUNCTION getfoo(int) RETURNS foo AS 'DECLARE footup foo%ROWTYPE; BEGIN SELECT * into footup FROM foo WHERE fooid = $1; RETURN footup; END;' LANGUAGE plpgsql;
 SELECT * FROM getfoo(1) AS t1;
 CREATE VIEW vw_getfoo AS SELECT * FROM getfoo(1);
 SELECT * FROM vw_getfoo;
diff --git a/src/test/regress/sql/rules.sql b/src/test/regress/sql/rules.sql
index ead8011a313..374e11d671c 100644
--- a/src/test/regress/sql/rules.sql
+++ b/src/test/regress/sql/rules.sql
@@ -431,7 +431,7 @@ create view rtest_vview4 as select X.a, X.b, count(Y.a) as refcount
 	group by X.a, X.b;
 create function rtest_viewfunc1(int4) returns int4 as
 	'select count(*)::int4 from rtest_view2 where a = $1'
-	language 'sql';
+	language sql;
 create view rtest_vview5 as select a, b, rtest_viewfunc1(a) as refcount
 	from rtest_view1;
 
diff --git a/src/test/regress/sql/triggers.sql b/src/test/regress/sql/triggers.sql
index e4f3bc4308b..140b0f2d485 100644
--- a/src/test/regress/sql/triggers.sql
+++ b/src/test/regress/sql/triggers.sql
@@ -218,7 +218,7 @@ COPY main_table (a,b) FROM stdin;
 80	15
 \.
 
-CREATE FUNCTION trigger_func() RETURNS trigger LANGUAGE 'plpgsql' AS '
+CREATE FUNCTION trigger_func() RETURNS trigger LANGUAGE plpgsql AS '
 BEGIN
 	RAISE NOTICE ''trigger_func() called: action = %, when = %, level = %'', TG_OP, TG_WHEN, TG_LEVEL;
 	RETURN NULL;
diff --git a/src/tutorial/funcs.source b/src/tutorial/funcs.source
index 4dfdf278333..919ec7de28d 100644
--- a/src/tutorial/funcs.source
+++ b/src/tutorial/funcs.source
@@ -6,7 +6,7 @@
 --
 -- Copyright (c) 1994-5, Regents of the University of California
 --
--- $PostgreSQL: pgsql/src/tutorial/funcs.source,v 1.7 2003/11/29 22:41:33 pgsql Exp $
+-- $PostgreSQL: pgsql/src/tutorial/funcs.source,v 1.8 2006/02/27 16:09:50 petere Exp $
 --
 ---------------------------------------------------------------------------
 
@@ -21,8 +21,8 @@
 -- let's create a simple SQL function that takes no arguments and 
 -- returns 1
 
-CREATE FUNCTION one() RETURNS int4
-   AS 'SELECT 1 as ONE' LANGUAGE 'sql';
+CREATE FUNCTION one() RETURNS integer
+   AS 'SELECT 1 as ONE' LANGUAGE SQL;
 
 --
 -- functions can be used in any expressions (eg. in the target list or 
@@ -34,8 +34,8 @@ SELECT one() AS answer;
 -- here's how you create a function that takes arguments. The following
 -- function returns the sum of its two arguments:
 
-CREATE FUNCTION add_em(int4, int4) RETURNS int4
-   AS 'SELECT $1 + $2' LANGUAGE 'sql';
+CREATE FUNCTION add_em(integer, integer) RETURNS integer
+   AS 'SELECT $1 + $2' LANGUAGE SQL;
 
 SELECT add_em(1, 2) AS answer;
 
@@ -50,8 +50,8 @@ SELECT add_em(1, 2) AS answer;
 
 CREATE TABLE EMP (
 	name		text,
-	salary		int4,
-	age		int4,
+	salary		integer,
+	age		integer,
 	cubicle		point
 );
 
@@ -64,8 +64,8 @@ INSERT INTO EMP VALUES ('Ginger', 4800, 30, '(2,4)');
 -- the argument of a function can also be a tuple. For instance, 
 -- double_salary takes a tuple of the EMP table
 
-CREATE FUNCTION double_salary(EMP) RETURNS int4
-   AS 'SELECT $1.salary * 2 AS salary' LANGUAGE 'sql';
+CREATE FUNCTION double_salary(EMP) RETURNS integer
+   AS 'SELECT $1.salary * 2 AS salary' LANGUAGE SQL;
 
 SELECT name, double_salary(EMP) AS dream
 FROM EMP
@@ -80,7 +80,7 @@ CREATE FUNCTION new_emp() RETURNS EMP
 			  1000 AS salary,
 			  25 AS age,
 			  \'(2,2)\'::point AS cubicle'
-   LANGUAGE 'sql';
+   LANGUAGE SQL;
 
 -- you can then project a column out of resulting the tuple by using the
 -- "function notation" for projection columns. (ie. bar(foo) is equivalent
@@ -91,7 +91,7 @@ SELECT name(new_emp()) AS nobody;
 -- let's try one more function that returns tuples
 CREATE FUNCTION high_pay() RETURNS setof EMP
    AS 'SELECT * FROM EMP where salary > 1500'
-   LANGUAGE 'sql';
+   LANGUAGE SQL;
 
 SELECT name(high_pay()) AS overpaid;
 
@@ -109,10 +109,10 @@ SELECT name(high_pay()) AS overpaid;
 --
 -- SELECT * FROM EMP;
 --
--- CREATE FUNCTION clean_EMP () RETURNS int4
+-- CREATE FUNCTION clean_EMP () RETURNS integer
 --	  AS 'DELETE FROM EMP WHERE EMP.salary <= 0\;
 --		  SELECT 1 AS ignore_this'
---	  LANGUAGE 'sql';
+--	  LANGUAGE SQL;
 --
 -- SELECT clean_EMP();
 --
@@ -125,17 +125,17 @@ SELECT name(high_pay()) AS overpaid;
 --	See funcs.c for the definition of the C functions.
 -----------------------------
 
-CREATE FUNCTION add_one(int4) RETURNS int4
-   AS '_OBJWD_/funcs' LANGUAGE 'c';
+CREATE FUNCTION add_one(integer) RETURNS integer
+   AS '_OBJWD_/funcs' LANGUAGE C;
 
 CREATE FUNCTION makepoint(point, point) RETURNS point
-   AS '_OBJWD_/funcs' LANGUAGE 'c';
+   AS '_OBJWD_/funcs' LANGUAGE C;
 
 CREATE FUNCTION copytext(text) RETURNS text
-   AS '_OBJWD_/funcs' LANGUAGE 'c';
+   AS '_OBJWD_/funcs' LANGUAGE C;
 
-CREATE FUNCTION c_overpaid(EMP, int4) RETURNS bool
-   AS '_OBJWD_/funcs' LANGUAGE 'c';
+CREATE FUNCTION c_overpaid(EMP, integer) RETURNS boolean
+   AS '_OBJWD_/funcs' LANGUAGE C;
 
 SELECT add_one(3) AS four;
 
@@ -149,14 +149,14 @@ WHERE name = 'Bill' or name = 'Sam';
 
 -- remove functions that were created in this file
 
-DROP FUNCTION c_overpaid(EMP, int4);
+DROP FUNCTION c_overpaid(EMP, integer);
 DROP FUNCTION copytext(text);
-DROP FUNCTION makepoint(point,point);
-DROP FUNCTION add_one(int4);
+DROP FUNCTION makepoint(point, point);
+DROP FUNCTION add_one(integer);
 --DROP FUNCTION clean_EMP();
 DROP FUNCTION high_pay();
 DROP FUNCTION new_emp();
-DROP FUNCTION add_em(int4, int4);
+DROP FUNCTION add_em(integer, integer);
 DROP FUNCTION one();
 DROP FUNCTION double_salary(EMP);