summaryrefslogtreecommitdiffstats
path: root/libkcal/libical/scripts
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commit460c52653ab0dcca6f19a4f492ed2c5e4e963ab0 (patch)
tree67208f7c145782a7e90b123b982ca78d88cc2c87 /libkcal/libical/scripts
downloadtdepim-460c52653ab0dcca6f19a4f492ed2c5e4e963ab0.tar.gz
tdepim-460c52653ab0dcca6f19a4f492ed2c5e4e963ab0.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'libkcal/libical/scripts')
-rw-r--r--libkcal/libical/scripts/Makefile.am9
-rwxr-xr-xlibkcal/libical/scripts/mkderivedcomponents.pl170
-rwxr-xr-xlibkcal/libical/scripts/mkderivedparameters.pl332
-rwxr-xr-xlibkcal/libical/scripts/mkderivedproperties.pl258
-rwxr-xr-xlibkcal/libical/scripts/mkderivedvalues.pl236
-rwxr-xr-xlibkcal/libical/scripts/mkparameterrestrictions.pl85
-rwxr-xr-xlibkcal/libical/scripts/mkrestrictionrecords.pl109
-rwxr-xr-xlibkcal/libical/scripts/mkrestrictiontable.pl98
-rw-r--r--libkcal/libical/scripts/readvaluesfile.pl130
9 files changed, 1427 insertions, 0 deletions
diff --git a/libkcal/libical/scripts/Makefile.am b/libkcal/libical/scripts/Makefile.am
new file mode 100644
index 000000000..47ce3e6e4
--- /dev/null
+++ b/libkcal/libical/scripts/Makefile.am
@@ -0,0 +1,9 @@
+EXTRA_DIST = \
+mkderivedcomponents.pl \
+mkderivedparameters.pl \
+mkderivedproperties.pl \
+mkderivedvalues.pl \
+mkparameterrestrictions.pl \
+mkrestrictionrecords.pl \
+mkrestrictiontable.pl \
+readvaluesfile.pl
diff --git a/libkcal/libical/scripts/mkderivedcomponents.pl b/libkcal/libical/scripts/mkderivedcomponents.pl
new file mode 100755
index 000000000..31743c3ba
--- /dev/null
+++ b/libkcal/libical/scripts/mkderivedcomponents.pl
@@ -0,0 +1,170 @@
+#!/usr/bin/env perl
+
+use Getopt::Std;
+getopts('chspi:');
+
+
+# ARG 0 is components.txt
+open(PV,"$ARGV[0]") || die "Can't open components file $ARGV[0]:$!";
+
+my @components;
+
+while (<PV>){
+
+ s/#.*//;
+
+ chop;
+
+ push(@components,$_);
+
+}
+
+close PV;
+
+# Write the file inline by copying everything before a demarcation
+# line, and putting the generated data after the demarcation
+
+if ($opt_i) {
+
+ open(IN,$opt_i) || die "Can't open input file \"$opt_i\"";
+
+ while(<IN>){
+
+ if (/Do not edit/){
+ last;
+ }
+
+ print;
+
+ }
+
+ if($opt_i){
+ print "# Everything below this line is machine generated. Do not edit. \n";
+ } else {
+ print "/* Everything below this line is machine generated. Do not edit. */\n";
+ }
+
+}
+
+if ($opt_c or $opt_h and !$opt_i){
+
+print <<EOM;
+/* -*- Mode: C -*-
+ ======================================================================
+ FILE: icalderivedproperties.{c,h}
+ CREATOR: eric 09 May 1999
+
+ \044Id:\044
+
+ (C) COPYRIGHT 1999 Eric Busboom
+ http://www.softwarestudio.org
+
+ The contents of this file are subject to the Mozilla Public License
+ Version 1.0 (the "License"); you may not use this file except in
+ compliance with the License. You may obtain a copy of the License at
+ http://www.mozilla.org/MPL/
+
+ Software distributed under the License is distributed on an "AS IS"
+ basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ the License for the specific language governing rights and
+ limitations under the License.
+
+
+ ======================================================================*/
+
+/*
+ * THIS FILE IS MACHINE GENERATED DO NOT EDIT
+ */
+
+#include <stdarg.h> /* for va_arg functions */
+
+EOM
+
+}
+
+if ($opt_p and !$opt_i){
+
+print <<EOM;
+
+EOM
+
+}
+
+
+foreach $comp (@components) {
+
+ next if !$comp;
+
+ my $ucf = join("",map {ucfirst(lc($_));} split(/-/,$comp));
+ my $lc = lc($ucf);
+ my $uc = uc($lc);
+
+ if($opt_c) { # Make C source
+ print<<EOM;
+
+/* $comp */
+
+icalcomponent* icalcomponent_new_${lc}()
+{
+ return (icalcomponent*)icalcomponent_new_impl(ICAL_${uc}_COMPONENT);
+}
+
+icalcomponent* icalcomponent_vanew_${lc}(...)
+{
+ va_list args;
+ struct icalcomponent_impl *impl = icalcomponent_new_impl(ICAL_${uc}_component);
+
+ va_start(args,v);
+ icalcomponent_add_properties(impl, args);
+ va_end(args);
+
+ return (icalcomponent*)impl;
+}
+
+EOM
+
+
+ } elsif ($opt_h) { # Make a C header
+ print<<EOM;
+
+/* $comp */
+icalcomponent* icalcomponent_new_${lc}();
+icalcomponent* icalcomponent_vanew_${lc}(...);
+EOM
+
+} elsif ($opt_s) { # Make something for a switch statement
+
+print <<EOM;
+case ICAL_${uc}_PROPERTY:
+EOM
+
+} elsif ($opt_p) { # make perl source
+
+print <<EOM;
+
+# $comp
+package Net::ICal::Component::${ucf};
+\@ISA=qw(Net::ICal::Component);
+
+sub new
+{
+ my \$package = shift;
+ my \$c = Net::ICal::icalcomponent_new(\$Net::ICal::ICAL_${uc}_COMPONENT);
+
+ my \$self = Net::ICal::Component::new_from_ref(\$c);
+ Net::ICal::Component::_add_elements(\$self,\\\@_);
+
+ # Self is blessed in new_from_ref
+
+ return \$self;
+
+}
+EOM
+
+}
+
+
+
+}
+
+
diff --git a/libkcal/libical/scripts/mkderivedparameters.pl b/libkcal/libical/scripts/mkderivedparameters.pl
new file mode 100755
index 000000000..9e8f92cdb
--- /dev/null
+++ b/libkcal/libical/scripts/mkderivedparameters.pl
@@ -0,0 +1,332 @@
+#!/usr/bin/env perl
+
+require "readvaluesfile.pl";
+
+use Getopt::Std;
+getopts('chspi:');
+
+%no_xname = (RELATED=>1,RANGE=>1,RSVP=>1,XLICERRORTYPE=>1,XLICCOMPARETYPE=>1);
+
+%params = read_parameters_file($ARGV[0]);
+
+
+# Write the file inline by copying everything before a demarcation
+# line, and putting the generated data after the demarcation
+
+if ($opt_i) {
+
+ open(IN,$opt_i) || die "Can't open input file $opt_i";
+
+ while(<IN>){
+ if (/<insert_code_here>/){
+ insert_code();
+ } else {
+ print;
+ }
+
+ }
+
+ if($opt_p){
+ print "# Everything below this line is machine generated. Do not edit. \n";
+ } else {
+ print "/* Everything below this line is machine generated. Do not edit. */\n";
+ }
+
+}
+
+sub insert_code
+{
+
+# Write parameter enumerations and datatypes
+
+if($opt_h){
+ print "typedef enum icalparameter_kind {\n ICAL_ANY_PARAMETER = 0,\n";
+ foreach $param (sort keys %params) {
+
+ next if !$param;
+
+ next if $param eq 'NO' or $param eq 'ANY';
+
+ my $uc = join("",map {uc($_);} split(/-/,$param));
+
+ my @enums = @{$params{$param}->{'enums'}};
+
+ print " ICAL_${uc}_PARAMETER, \n";
+
+ }
+ print " ICAL_NO_PARAMETER\n} icalparameter_kind;\n\n";
+
+ # Now create enumerations for parameter values
+ $idx = 20000;
+
+ print "#define ICALPARAMETER_FIRST_ENUM $idx\n\n";
+
+ foreach $param (sort keys %params) {
+
+ next if !$param;
+
+ next if $param eq 'NO' or $prop eq 'ANY';
+
+ my $type = $params{$param}->{"C"};
+ my $ucv = join("",map {uc(lc($_));} split(/-/,$param));
+ my @enums = @{$params{$param}->{'enums'}};
+
+ if(@enums){
+
+ print "typedef enum $type {\n";
+ my $first = 1;
+
+ unshift(@enums,"X");
+
+ push(@enums,"NONE");
+
+ foreach $e (@enums) {
+ if (!$first){
+ print ",\n";
+ } else {
+ $first = 0;
+ }
+
+ my $uce = join("",map {uc(lc($_));} split(/-/,$e));
+
+ print " ICAL_${ucv}_${uce} = $idx";
+
+ $idx++;
+ }
+ $c_type =~ s/enum //;
+
+ print "\n} $type;\n\n";
+ }
+ }
+
+ print "#define ICALPARAMETER_LAST_ENUM $idx\n\n";
+
+}
+
+if ($opt_c){
+
+
+ # Create the icalparameter_value to icalvalue_kind conversion table
+ my $count = 0;
+ my $out;
+
+ foreach $enum (@{$params{'VALUE'}->{'enums'}}){
+ next if $enum eq 'NO' or $enum eq 'ERROR';
+ $uc = join("",map {uc(lc($_));} split(/-/,$enum));
+ $out.=" {ICAL_VALUE_${uc},ICAL_${uc}_VALUE},\n";
+ $count++;
+ }
+
+ $count+=2;
+ print "struct icalparameter_value_kind_map value_kind_map[$count] = {\n";
+ print $out;
+ print " {ICAL_VALUE_X,ICAL_X_VALUE},\n";
+ print " {ICAL_VALUE_NONE,ICAL_NO_VALUE}\n};\n\n";
+
+ #Create the parameter Name map
+
+ $out="";
+ $count=0;
+ foreach $param (sort keys %params) {
+
+ next if !$param;
+
+ next if $param eq 'NO' or $prop eq 'ANY';
+
+ my $lc = join("",map {lc($_);} split(/-/,$param));
+ my $uc = join("",map {uc(lc($_));} split(/-/,$param));
+
+ $count++;
+ $out.=" {ICAL_${uc}_PARAMETER,\"$param\"},\n";
+
+ }
+ $count+=1;
+ print "struct icalparameter_kind_map parameter_map[$count] = { \n";
+ print $out;
+ print " { ICAL_NO_PARAMETER, \"\"}\n};\n\n";
+
+ # Create the parameter value map
+ $out ="";
+ $count=0;
+ foreach $param (sort keys %params) {
+
+ next if !$param;
+
+ next if $param eq 'NO' or $prop eq 'ANY';
+
+ my $type = $params{$param}->{"C"};
+ my $uc = join("",map {uc(lc($_));} split(/-/,$param));
+ my @enums = @{$params{$param}->{'enums'}};
+
+ if(@enums){
+
+ foreach $e (@enums){
+ my $uce = join("",map {uc(lc($_));} split(/-/,$e));
+
+ $count++;
+ $out.=" {ICAL_${uc}_PARAMETER,ICAL_${uc}_${uce},\"$e\"},\n";
+ }
+
+ }
+ }
+
+ $count+=3;
+ print "struct icalparameter_map icalparameter_map[] = {\n";
+ print "{ICAL_ANY_PARAMETER,0,\"\"},\n";
+ print $out;
+ print " {ICAL_NO_PARAMETER,0,\"\"}};\n\n";
+
+}
+
+foreach $param (keys %params){
+
+ my $type = $params{$param}->{'C'};
+
+ my $ucf = join("",map {ucfirst(lc($_));} split(/-/,$param));
+
+ my $lc = lc($ucf);
+ my $uc = uc($lc);
+
+ my $charorenum;
+ my $set_code;
+ my $pointer_check;
+ my $pointer_check_v;
+ my $xrange;
+
+ if ($type=~/char/ ) {
+
+ $charorenum = " icalerror_check_arg_rz( (param!=0), \"param\");\n return param->string;";
+
+ $set_code = "((struct icalparameter_impl*)param)->string = icalmemory_strdup(v);";
+
+ $pointer_check = "icalerror_check_arg_rz( (v!=0),\"v\");";
+ $pointer_check_v = "icalerror_check_arg_rv( (v!=0),\"v\");";
+
+ } else {
+
+ $xrange =" if (param->string != 0){\n return ICAL_${uc}_X;\n }\n" if !exists $no_xname{$uc};
+
+ $charorenum= "icalerror_check_arg( (param!=0), \"param\");\n$xrange\nreturn ($type)(param->data);";
+
+ $pointer_check = "icalerror_check_arg_rz(v >= ICAL_${uc}_X,\"v\");\n icalerror_check_arg_rz(v < ICAL_${uc}_NONE,\"v\");";
+
+ $pointer_check_v = "icalerror_check_arg_rv(v >= ICAL_${uc}_X,\"v\");\n icalerror_check_arg_rv(v < ICAL_${uc}_NONE,\"v\");";
+
+ $set_code = "((struct icalparameter_impl*)param)->data = (int)v;";
+
+ }
+
+
+
+ if ($opt_c) {
+
+ print <<EOM;
+/* $param */
+icalparameter* icalparameter_new_${lc}($type v)
+{
+ struct icalparameter_impl *impl;
+ icalerror_clear_errno();
+ $pointer_check
+ impl = icalparameter_new_impl(ICAL_${uc}_PARAMETER);
+ if (impl == 0) {
+ return 0;
+ }
+
+ icalparameter_set_${lc}((icalparameter*) impl,v);
+ if (icalerrno != ICAL_NO_ERROR) {
+ icalparameter_free((icalparameter*) impl);
+ return 0;
+ }
+
+ return (icalparameter*) impl;
+}
+
+${type} icalparameter_get_${lc}(const icalparameter* param)
+{
+ icalerror_clear_errno();
+$charorenum
+}
+
+void icalparameter_set_${lc}(icalparameter* param, ${type} v)
+{
+ $pointer_check_v
+ icalerror_check_arg_rv( (param!=0), "param");
+ icalerror_clear_errno();
+
+ $set_code
+}
+
+EOM
+
+ } elsif( $opt_h) {
+
+ print <<EOM;
+/* $param */
+icalparameter* icalparameter_new_${lc}($type v);
+${type} icalparameter_get_${lc}(const icalparameter* value);
+void icalparameter_set_${lc}(icalparameter* value, ${type} v);
+
+EOM
+
+}
+
+if ($opt_p) {
+
+ print <<EOM;
+
+# $param
+
+package Net::ICal::Parameter::${ucf};
+\@ISA=qw(Net::ICal::Parameter);
+
+sub new
+{
+ my \$self = [];
+ my \$package = shift;
+ my \$value = shift;
+
+ bless \$self, \$package;
+
+ my \$p;
+
+ if (\$value) {
+ \$p = Net::ICal::icalparameter_new_from_string(\$Net::ICal::ICAL_${uc}_PARAMETER,\$value);
+ } else {
+ \$p = Net::ICal::icalparameter_new(\$Net::ICal::ICAL_${uc}_PARAMETER);
+ }
+
+ \$self->[0] = \$p;
+
+ return \$self;
+}
+
+sub get
+{
+ my \$self = shift;
+ my \$impl = \$self->_impl();
+
+ return Net::ICal::icalparameter_as_ical_string(\$impl);
+
+}
+
+sub set
+{
+ # This is hard to implement, so I've punted for now.
+ die "Set is not implemented";
+}
+
+EOM
+
+}
+
+}
+
+if ($opt_h){
+
+print <<EOM;
+#endif /*ICALPARAMETER_H*/
+
+EOM
+}
+
+}
diff --git a/libkcal/libical/scripts/mkderivedproperties.pl b/libkcal/libical/scripts/mkderivedproperties.pl
new file mode 100755
index 000000000..4eafb1927
--- /dev/null
+++ b/libkcal/libical/scripts/mkderivedproperties.pl
@@ -0,0 +1,258 @@
+#!/usr/bin/env perl
+
+require "readvaluesfile.pl";
+
+use Getopt::Std;
+getopts('chspmi:');
+
+# ARG 0 is properties.csv
+%propmap = read_properties_file($ARGV[0]);
+
+# ARG 1 is value-types.txt
+%valuemap = read_values_file($ARGV[1]);
+
+
+$include_vanew = 1;
+
+# Write the file inline by copying everything before a demarcation
+# line, and putting the generated data after the demarcation
+
+if ($opt_i) {
+
+ open(IN,$opt_i) || die "Can't open input file $opt_i";
+
+ while(<IN>){
+
+ if (/<insert_code_here>/){
+ insert_code();
+ } else {
+ print;
+ }
+
+ }
+
+}
+
+sub fudge_data {
+ my $prop = shift;
+
+ my $value = $propmap{$prop}->{'lic_value'};
+
+ if (!$value){
+ die "Can't find value for property \"$prop\"\n";
+ }
+ my $ucf = join("",map {ucfirst(lc($_));} split(/-/,$prop));
+ my $lc = lc($ucf);
+ my $uc = uc($lc);
+
+ my $ucfvalue = join("",map {ucfirst(lc($_));} split(/-/,$value));
+ my $lcvalue = lc($ucfvalue);
+ my $ucvalue = uc($lcvalue);
+
+ my $type = $valuemap{$value}->{C}->[1];
+
+ return ($uc,$lc,$lcvalue,$ucvalue,$type);
+
+}
+
+sub insert_code {
+
+# Create the property map data
+if($opt_c){
+
+
+ my @props = sort keys %propmap;
+ my $count = scalar(@props);
+
+
+ print "struct icalproperty_map property_map[$count] = {\n";
+
+ foreach $prop (@props) {
+
+ next if !$prop;
+
+ next if $prop eq 'NO';
+
+ my ($uc,$lc,$lcvalue,$ucvalue,$type) = fudge_data($prop);
+
+ print "{ICAL_${uc}_PROPERTY,\"$prop\",ICAL_${ucvalue}_VALUE},\n";
+
+ }
+
+ $prop = "NO";
+
+ my ($uc,$lc,$lcvalue,$ucvalue,$type) = fudge_data($prop);
+
+ print "{ICAL_${uc}_PROPERTY,\"\",ICAL_NO_VALUE}};\n\n";
+
+ $idx = 10000;
+ $count = 1;
+ my $out = "";
+
+ foreach $value (sort keys %valuemap) {
+
+ next if !$value;
+ next if $value eq 'NO' or $prop eq 'ANY';
+
+ my $ucv = join("",map {uc(lc($_));} split(/-/,$value));
+ my @enums = @{$valuemap{$value}->{'enums'}};
+
+ if(@enums){
+
+ my ($c_autogen,$c_type) = @{$valuemap{$value}->{'C'}};
+
+ unshift(@enums,"X");
+ push(@enums,"NONE");
+
+ foreach $e (@enums) {
+
+ my $uce = join("",map {uc(lc($_));} split(/-/,$e));
+
+ if($e ne "X" and $e ne "NONE"){
+ $str = $e;
+ } else {
+ $str = "";
+ }
+
+ $out.=" {ICAL_${ucv}_PROPERTY,ICAL_${ucv}_${uce},\"$str\" }, /*$idx*/\n";
+
+ $idx++;
+ $count++;
+ }
+
+ }
+ }
+
+ $count++;
+ print "struct icalproperty_enum_map enum_map[$count] = {\n";
+ print $out;
+ print " {ICAL_NO_PROPERTY,0,\"\"}\n};\n\n";
+
+
+
+}
+
+
+if($opt_h){
+
+ # Create the property enumerations list
+ print "typedef enum icalproperty_kind {\n ICAL_ANY_PROPERTY = 0,\n";
+ foreach $prop (sort keys %propmap) {
+
+ next if !$prop;
+
+ next if $prop eq 'NO' or $prop eq 'ANY';
+
+ my ($uc,$lc,$lcvalue,$ucvalue,$type) = fudge_data($prop);
+
+ print " ICAL_${uc}_PROPERTY, \n";
+
+ }
+ print " ICAL_NO_PROPERTY\n} icalproperty_kind;\n\n";
+
+
+}
+
+
+foreach $prop (sort keys %propmap) {
+
+ next if !$prop;
+
+ next if $prop eq 'NO' or $prop eq 'ANY';
+
+ my ($uc,$lc,$lcvalue,$ucvalue,$type) = fudge_data($prop);
+
+
+ my $pointer_check;
+ if ($type =~ /\*/){
+ $pointer_check = "icalerror_check_arg_rz( (v!=0),\"v\");\n" if $type =~ /\*/;
+ } elsif ( $type eq "void" ){
+ $pointer_check = "icalerror_check_arg_rv( (v!=0),\"v\");\n" if $type =~ /\*/;
+
+ }
+
+ my $set_pointer_check = "icalerror_check_arg_rv( (v!=0),\"v\");\n" if $type =~ /\*/;
+
+ if($opt_c) { # Generate C source
+
+ if ($include_vanew) {
+ print<<EOM;
+icalproperty* icalproperty_vanew_${lc}($type v, ...){
+ va_list args;
+ struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_${uc}_PROPERTY); $pointer_check
+ icalproperty_set_${lc}((icalproperty*)impl,v);
+ va_start(args,v);
+ icalproperty_add_parameters(impl, args);
+ va_end(args);
+ return (icalproperty*)impl;
+}
+EOM
+}
+ print<<EOM;
+
+/* $prop */
+icalproperty* icalproperty_new_${lc}($type v) {
+ struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_${uc}_PROPERTY); $pointer_check
+ icalproperty_set_${lc}((icalproperty*)impl,v);
+ return (icalproperty*)impl;
+}
+
+EOM
+ # Allow DTSTART, DTEND, DUE, EXDATE and RECURRENCE-ID to take DATE values.
+ if ($lc eq "dtstart" || $lc eq "dtend" || $lc eq "due" || $lc eq "exdate"
+ || $lc eq "recurrenceid") {
+ print<<EOM;
+void icalproperty_set_${lc}(icalproperty* prop, $type v){
+ icalvalue *value;
+ $set_pointer_check
+ icalerror_check_arg_rv( (prop!=0),"prop");
+ if (v.is_date)
+ value = icalvalue_new_date(v);
+ else
+ value = icalvalue_new_datetime(v);
+ icalproperty_set_value(prop,value);
+}
+EOM
+ } else {
+
+ print<<EOM;
+void icalproperty_set_${lc}(icalproperty* prop, $type v){
+ $set_pointer_check
+ icalerror_check_arg_rv( (prop!=0),"prop");
+ icalproperty_set_value(prop,icalvalue_new_${lcvalue}(v));
+}
+EOM
+ }
+ print<<EOM;
+$type icalproperty_get_${lc}(const icalproperty* prop){
+ icalerror_check_arg( (prop!=0),"prop");
+ return icalvalue_get_${lcvalue}(icalproperty_get_value(prop));
+}
+EOM
+ } elsif ($opt_h) { # Generate C Header file
+
+
+ print "\
+/* $prop */\
+icalproperty* icalproperty_new_${lc}($type v);\
+void icalproperty_set_${lc}(icalproperty* prop, $type v);\
+$type icalproperty_get_${lc}(const icalproperty* prop);";
+
+
+if ($include_vanew){
+ print "icalproperty* icalproperty_vanew_${lc}($type v, ...);\n";
+}
+
+}
+
+
+} # This brace terminates the main loop
+
+
+
+if ($opt_h){
+
+print "\n\n#endif /*ICALPROPERTY_H*/\n"
+}
+
+}
diff --git a/libkcal/libical/scripts/mkderivedvalues.pl b/libkcal/libical/scripts/mkderivedvalues.pl
new file mode 100755
index 000000000..fef659c30
--- /dev/null
+++ b/libkcal/libical/scripts/mkderivedvalues.pl
@@ -0,0 +1,236 @@
+#!/usr/bin/perl
+
+use lib '.';
+
+require 'readvaluesfile.pl';
+
+use Getopt::Std;
+getopts('chi:');
+
+ #Options
+ # c -> generate c code file
+ # h-> generate header file
+
+ # Open with value-types.txt
+
+my %h = read_values_file($ARGV[0]);
+
+
+ # Write the file inline by copying everything before a demarcation
+ # line, and putting the generated data after the demarcation
+
+if ($opt_i) {
+
+ open(IN,$opt_i) || die "Can't open input file $opt_i";
+
+ while(<IN>){
+ if (/<insert_code_here>/){
+ insert_code();
+ } else {
+ print;
+ }
+
+
+ }
+}
+
+sub insert_code
+{
+ # Map type names to the value in the icalvalue_impl data union */
+
+%union_map = (
+ BOOLEAN => 'int',
+ CALADDRESS=>'string',
+ DATE=>'time',
+ DATETIME=>'time',
+ DATETIMEDATE=>'time',
+ DATETIMEPERIOD=>'period',
+ DURATION=>'duration',
+ INTEGER=>'int',
+ TEXT=>'string',
+ URI=>'string',
+ UTCOFFSET=>'int',
+ QUERY=>'string',
+ BINARY=>'string',
+ X=>'string'
+ );
+
+
+if($opt_h){
+
+ # First print out the value enumerations
+ $idx = 5000;
+ print "typedef enum icalvalue_kind {\n";
+ print " ICAL_ANY_VALUE=$idx,\n";
+
+ foreach $value (keys %h) {
+
+ $idx++;
+ my $ucv = join("",map {uc(lc($_));} split(/-/,$value));
+
+ next if $value eq "NO";
+
+ print " ICAL_${ucv}_VALUE=$idx,\n";
+ }
+
+ $idx++;
+ print " ICAL_NO_VALUE=$idx\n} icalvalue_kind ;\n\n";
+
+ # Now create enumerations for property values
+ $idx = 10000;
+
+ print "#define ICALPROPERTY_FIRST_ENUM $idx\n\n";
+
+ foreach $value (sort keys %h) {
+
+ next if !$value;
+
+ next if $value eq 'NO' or $prop eq 'ANY';
+
+ my $ucv = join("",map {uc(lc($_));} split(/-/,$value));
+ my @enums = @{$h{$value}->{'enums'}};
+
+ if(@enums){
+
+ my ($c_autogen,$c_type) = @{$h{$value}->{'C'}};
+ print "typedef $c_type {\n";
+ my $first = 1;
+
+ unshift(@enums,"X");
+
+ push(@enums,"NONE");
+
+ foreach $e (@enums) {
+ if (!$first){
+ print ",\n";
+ } else {
+ $first = 0;
+ }
+
+ my $uce = join("",map {uc(lc($_));} split(/-/,$e));
+
+ print " ICAL_${ucv}_${uce} = $idx";
+
+ $idx++;
+ }
+
+ $c_type =~ s/enum //;
+
+ print "\n} $c_type;\n\n";
+ }
+ }
+
+ print "#define ICALPROPERTY_LAST_ENUM $idx\n\n";
+
+}
+
+
+if($opt_c){
+
+ # print out the value to string map
+
+ my $count = scalar(keys %h) + 1;
+ print "struct icalvalue_kind_map value_map[$count]={\n";
+
+ foreach $value (keys %h) {
+
+ $idx++;
+ my $ucv = join("",map {uc(lc($_));} split(/-/,$value));
+
+ next if $value eq "NO";
+
+ print " {ICAL_${ucv}_VALUE,\"$value\"},\n";
+ }
+
+
+ print " {ICAL_NO_VALUE,\"\"}\n};";
+
+}
+
+
+foreach $value (keys %h) {
+
+ my $autogen = $h{$value}->{C}->[0];
+ my $type = $h{$value}->{C}->[1];
+
+ my $ucf = join("",map {ucfirst(lc($_));} split(/-/,$value));
+
+ my $lc = lc($ucf);
+ my $uc = uc($lc);
+
+ my $pointer_check = "icalerror_check_arg_rz( (v!=0),\"v\");\n" if $type =~ /\*/;
+ my $pointer_check_rv = "icalerror_check_arg_rv( (v!=0),\"v\");\n" if $type =~ /\*/;
+
+ my $assign;
+
+ if ($type =~ /char/){
+ $assign = "icalmemory_strdup(v);\n\n if (impl->data.v_string == 0){\n errno = ENOMEM;\n }\n";
+ } else {
+ $assign = "v;";
+ }
+
+ my $union_data;
+
+ if(@{$h{$value}->{'enums'}}){
+ $union_data = 'enum';
+
+ } elsif (exists $union_map{$uc} ){
+ $union_data=$union_map{$uc};
+ } else {
+ $union_data = $lc;
+ }
+
+ if ($opt_c && $autogen) {
+
+ print "\n\n\
+icalvalue* icalvalue_new_${lc} ($type v){\
+ struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_${uc}_VALUE);\
+ $pointer_check\
+ icalvalue_set_${lc}((icalvalue*)impl,v);\
+ return (icalvalue*)impl;\
+}\
+void icalvalue_set_${lc}(icalvalue* value, $type v) {\
+ struct icalvalue_impl* impl; \
+ icalerror_check_arg_rv( (value!=0),\"value\");\
+ $pointer_check_rv\
+ icalerror_check_value_type(value, ICAL_${uc}_VALUE);\
+ impl = (struct icalvalue_impl*)value;\n";
+
+ if( $union_data eq 'string') {
+
+ print " if(impl->data.v_${union_data}!=0) {free((void*)impl->data.v_${union_data});}\n";
+ }
+
+
+ print "\n\
+ impl->data.v_$union_data = $assign \n\
+ icalvalue_reset_kind(impl);\n}\n";
+
+ print "$type\ icalvalue_get_${lc}(const icalvalue* value)\ {\n";
+ if ($type =~ m/(\*|int|float)$/) {
+ print " icalerror_check_arg_rz( (value!=0),\"value\");\n";
+ } else {
+ print " icalerror_check_arg( (value!=0),\"value\");\n";
+ }
+ print " icalerror_check_value_type(value, ICAL_${uc}_VALUE);\
+ return ((struct icalvalue_impl*)value)->data.v_${union_data};\n}\n";
+
+
+ } elsif($opt_h && $autogen) {
+
+ print "\n /* $value */ \
+icalvalue* icalvalue_new_${lc}($type v); \
+$type icalvalue_get_${lc}(const icalvalue* value); \
+void icalvalue_set_${lc}(icalvalue* value, ${type} v);\n\n";
+
+ }
+
+}
+
+
+if ($opt_h){
+ print "#endif /*ICALVALUE_H*/\n";
+ }
+
+
+}
diff --git a/libkcal/libical/scripts/mkparameterrestrictions.pl b/libkcal/libical/scripts/mkparameterrestrictions.pl
new file mode 100755
index 000000000..2c57eb4ca
--- /dev/null
+++ b/libkcal/libical/scripts/mkparameterrestrictions.pl
@@ -0,0 +1,85 @@
+#!/usr/bin/perl
+
+# Version: 1.0
+# Script last updated: 30May1999 GMD
+# Change log:
+# <none>
+
+
+# usually open params-in-prop.txt
+open(F,"$ARGV[0]") || die "Can't open restriction file $ARGV[0]:$!";
+
+print <<EOM;
+/*
+ ======================================================================
+ File: parameterrestrictions.c
+
+ (C) COPYRIGHT 1999 Graham Davison
+ mailto:g.m.davison\@computer.org
+
+ The contents of this file are subject to the Mozilla Public License
+ Version 1.0 (the "License"); you may not use this file except in
+ compliance with the License. You may obtain a copy of the License at
+ http://www.mozilla.org/MPL/
+
+ Software distributed under the License is distributed on an "AS IS"
+ basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ the License for the specific language governing rights and
+ limitations under the License.
+
+
+ ======================================================================*/
+
+/*
+ * THIS FILE IS MACHINE GENERATED DO NOT EDIT
+ */
+
+
+int icalrestriction_is_parameter_allowed(icalproperty_kind prop,icalparameter_kind param)
+{
+ switch (prop)
+ {
+EOM
+
+while(<F>)
+{
+ chop;
+
+ # split line by whitespace
+ my @v = split(/\s+/,$_);
+ # property is first item on line
+ my $prop = shift @v;
+ my $prop_name = $prop;
+ if (substr($prop,0,1) eq "X") { $prop = "X"; }
+ $prop = join("",split(/-/,$prop));
+
+print <<EOM;
+
+ /* ${prop_name} */
+ case ICAL_${prop}_PROPERTY:
+ switch (param)
+ {
+EOM
+
+ foreach $param (@v)
+ {
+ $param = join("",split(/-/,$param));
+ print "\t\t\t\tcase ICAL_${param}_PARAMETER:\n";
+ }
+
+print <<EOM;
+ return 1;
+ default:
+ return 0;
+ }
+
+EOM
+
+}
+
+print <<EOM;
+ }
+
+ return 0;
+}
+EOM
diff --git a/libkcal/libical/scripts/mkrestrictionrecords.pl b/libkcal/libical/scripts/mkrestrictionrecords.pl
new file mode 100755
index 000000000..dd28d7770
--- /dev/null
+++ b/libkcal/libical/scripts/mkrestrictionrecords.pl
@@ -0,0 +1,109 @@
+#!/usr/bin/env perl
+
+# Version: 1.0
+# Script last updated: 30May1999 GMD
+# Change log:
+# <none>
+
+# usually open restrictions.csv
+open(F,"$ARGV[0]") || die "Can't open restriction file $ARGV[0]:$!";
+
+print <<EOM;
+/*
+ ======================================================================
+ File: restrictionrecords.c
+
+ (C) COPYRIGHT 1999 Graham Davison
+ mailto:g.m.davison\@computer.org
+
+ The contents of this file are subject to the Mozilla Public License
+ Version 1.0 (the "License"); you may not use this file except in
+ compliance with the License. You may obtain a copy of the License at
+ http://www.mozilla.org/MPL/
+
+ Software distributed under the License is distributed on an "AS IS"
+ basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ the License for the specific language governing rights and
+ limitations under the License.
+
+
+ ======================================================================*/
+
+
+/*
+ * THIS FILE IS MACHINE GENERATED DO NOT EDIT
+ */
+
+
+typedef struct icalrestriction_record {
+ icalproperty_method method;
+ icalcomponent_kind component;
+ icalproperty_kind property;
+ icalcomponent_kind subcomponent;
+ icalrestriction_kind restriction;
+} icalrestriction_record;
+
+
+icalrestriction_record icalrestriction_records[] =
+{
+EOM
+
+my $last_method = "";
+my $last_component = "";
+my $last_property = "";
+my $need_header = 0;
+
+while(<F>)
+{
+ chop;
+
+ # split line at commas
+ my ($method,$component,$property,$subcomponent,$restriction)=split(/\,/,$_);
+
+ #
+ #put in code to generate comments here!
+ #
+ if ($method ne $last_method)
+ {
+ $need_header = 1;
+ $last_method = $method;
+ }
+ if ($component ne $last_component)
+ {
+ $need_header = 1;
+ $last_component = $component;
+ }
+
+ if ($need_header)
+ {
+ print "\n\t/* METHOD: ${method}, COMPONENT: ${component} */\n";
+ $need_header = 0;
+ }
+
+ foreach $item ($component,$property,$subcomponent,$restriction)
+ {
+ # handle special cases.
+ if ($item eq "NONE")
+ { $item = "NO"; }
+ else { if (substr($item,0,1) eq "X")
+ { $item = "X"; }}
+
+ # strip out dashes
+ $item = join("",split(/-/,$item));
+ }
+ # strip leading V from component names
+ $component =~ s/^(V?)(\w+?)((SAVINGS)?)((TIME)?)$/$2/;
+ $subcomponent =~ s/^V(\w+)/$1/;
+
+ print "\t\{ICAL_METHOD_${method},ICAL_${component}_COMPONENT,";
+ print "ICAL_${property}_PROPERTY,ICAL_${subcomponent}_COMPONENT,";
+ print "ICAL_RESTRICTION_${restriction}\},\n";
+
+}
+
+print <<EOM;
+
+ /* END */
+ {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_PROPERTY,ICAL_NO_COMPONENT,ICAL_RESTRICTION_NONE}
+};
+EOM
diff --git a/libkcal/libical/scripts/mkrestrictiontable.pl b/libkcal/libical/scripts/mkrestrictiontable.pl
new file mode 100755
index 000000000..0e4e65c09
--- /dev/null
+++ b/libkcal/libical/scripts/mkrestrictiontable.pl
@@ -0,0 +1,98 @@
+#!/usr/bin/env perl
+
+use Getopt::Std;
+getopts('i:');
+
+# the argument should be the path to the restriction datafile, usually
+# design-data/restrictions.csv
+open(F,"$ARGV[0]") || die "Can't open restriction data file $ARGV[0]:$!";
+
+# Write the file inline by copying everything before a demarcation
+# line, and putting the generated data after the demarcation
+
+if ($opt_i) {
+
+ open(IN,$opt_i) || die "Can't open input file $opt_i";
+
+ while(<IN>){
+
+ if (/Do not edit/){
+ last;
+ }
+
+ print;
+
+ }
+
+ print "/* Everything below this line is machine generated. Do not edit. */\n";
+
+
+ close IN;
+}
+
+# First build the property restriction table
+print "icalrestriction_property_record icalrestriction_property_records[] = {\n";
+
+while(<F>)
+{
+
+ chop;
+
+ s/\#.*$//;
+
+ my($method,$targetcomp,$prop,$subcomp,$restr,$sub) = split(/,/,$_);
+
+ next if !$method;
+
+ if(!$sub) {
+ $sub = "0";
+ } else {
+ $sub = "icalrestriction_".$sub;
+ }
+
+ if($prop ne "NONE"){
+ print(" \{ICAL_METHOD_${method},ICAL_${targetcomp}_COMPONENT,ICAL_${prop}_PROPERTY,ICAL_RESTRICTION_${restr},$sub},\n");
+ }
+
+}
+
+
+# Print the terminating line
+print " {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_PROPERTY,ICAL_RESTRICTION_NONE, 0}\n";
+
+print "};\n";
+
+print "icalrestriction_component_record icalrestriction_component_records[] = {\n";
+
+
+# Go back through the entire file and build the component restriction table
+close(F);
+open(F,"$ARGV[0]") || die "Can't open restriction data file $ARGV[0]:$!";
+
+while(<F>)
+{
+
+ chop;
+
+ s/\#.*$//;
+
+ my($method,$targetcomp,$prop,$subcomp,$restr,$sub) = split(/,/,$_);
+
+ next if !$method;
+
+ if(!$sub) {
+ $sub = "0";
+ } else {
+ $sub = "icalrestriction_".$sub;
+ }
+
+
+ if($subcomp ne "NONE"){
+ print(" \{ICAL_METHOD_${method},ICAL_${targetcomp}_COMPONENT,ICAL_${subcomp}_COMPONENT,ICAL_RESTRICTION_${restr},$sub\},\n");
+ }
+
+}
+
+# print the terminating line
+print " {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_COMPONENT,ICAL_RESTRICTION_NONE, 0}\n";
+print "};\n";
diff --git a/libkcal/libical/scripts/readvaluesfile.pl b/libkcal/libical/scripts/readvaluesfile.pl
new file mode 100644
index 000000000..d5e2d36fd
--- /dev/null
+++ b/libkcal/libical/scripts/readvaluesfile.pl
@@ -0,0 +1,130 @@
+
+
+sub read_values_file {
+
+ my $path = shift;
+ my %h;
+
+ open(F,$path) || die "Can't open values file $path";
+
+ while(<F>){
+
+ chop;
+
+ s/#.*$//g;
+ s/\"//g;
+
+ next if ! $_;
+
+ @column = split(/,/,$_);
+
+ my $value_name = $column[0];
+
+ my $c_type_str = $column[1];
+ my $c_autogen = ($c_type_str =~ /\(a\)/);
+
+ my $c_type = $c_type_str;
+ $c_type =~ s/\(.\)//;
+
+ my $python_type = $column[2];
+ my $components = $column[3];
+ my $enum_values = $column[4];
+
+ my @components;
+ if($components ne "unitary"){
+ @components = split(/;/,$components);
+ } else {
+ @components = ();
+ }
+
+ my @enums;
+ if($enum_values) {
+ @enums = split(/;/,$enum_values);
+
+ } else {
+ @enums = ();
+ }
+
+ $h{$value_name} = { C => [$c_autogen,$c_type],
+ perl => $perl_type,
+ python => $python_type,
+ components=>[@components],
+ enums=>[@enums]
+ };
+ }
+
+ return %h;
+}
+
+sub read_properties_file {
+
+ my $path = shift;
+ my %h;
+
+ open(F,$path) || die "Can't open properties file $path";
+
+ while(<F>){
+
+ chop;
+
+ s/#.*$//g;
+ s/\"//g;
+
+ next if ! $_;
+
+ @column = split(/,/,$_);
+
+ my $property_name = $column[0];
+
+ my $lic_value = $column[1];
+ my $default_value = $column[2];
+
+ $h{$property_name} = { lic_value => $lic_value,
+ default_value => $default_value
+ };
+ }
+
+ return %h;
+}
+
+sub read_parameters_file {
+
+ my $path = shift;
+ my %h;
+
+ open(F,$path) || die "Can't open parameters file $path";
+
+ while(<F>){
+
+ chop;
+
+ s/#.*$//g;
+ s/\"//g;
+
+ next if ! $_;
+
+ @column = split(/\,/,$_);
+
+ my $parameter_name = $column[0];
+
+ my $data_type = $column[1];
+ my $enum_string = $column[2];
+
+ my @enums;
+ if($enum_string){
+ @enums = split(/;/,$enum_string);
+ }
+
+ $h{$parameter_name} = { C => $data_type,
+ enums => [@enums]
+ };
+ }
+
+ close(F);
+
+ return %h;
+}
+
+
+
+1;