Changeset 1914


Ignore:
Timestamp:
Jan 28, 2003, 11:23:32 PM (18 years ago)
Author:
ranger
Message:

fink conversion of pilot-link (needed by kdepim3)
also, kdepim3 actually builds now =)

Location:
trunk/dports
Files:
6 added
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/dports/x11/kdeartwork3/files/patch-kdeartwork3-3.1.darwin

    r1900 r1914  
    22RCS file: IconThemes/Crystal/48x48/mimetypes/-font_bitmap.png
    33diff -N IconThemes/Crystal/48x48/mimetypes/-font_bitmap.png
    4 Binary files /dev/null and /tmp/cvstBeBUU differ
    54--- kscreensaver/kdesavers/Euphoria.cpp 10 Dec 2002 19:25:01 -0000      1.1.1.4
    65+++ kscreensaver/kdesavers/Euphoria.cpp 10 Dec 2002 19:44:01 -0000      1.3
  • trunk/dports/x11/kdebase3/files/patch-kdebase3-3.1.darwin

    r1900 r1914  
    11
    22--- startkde    1 Dec 2002 15:20:59 -0000       1.1.1.6
    3 +++ startkde    12 Jan 2003 18:00:02 -0000      1.9
    4 @@ -34,6 +34,9 @@
     3+++ startkde    27 Jan 2003 16:06:02 -0000      1.10
     4@@ -34,6 +34,10 @@
    55 # people's heads. We use colours from the standard KDE palette for those with
    66 # palettised displays.
     
    88+# we have to unset this for Darwin since it will screw up KDE's dynamic-loading
    99+unset DYLD_FORCE_FLAT_NAMESPACE
     10+test -d "@PREFIX@" && export PATH="@PREFIX@/bin:${PATH}"
    1011+
    1112 test "$XDM_MANAGED" || bkg="-solid #C0C0C0"
    1213 xsetroot -cursor_name left_ptr $bkg
    1314 
    14 @@ -110,6 +113,11 @@
     15@@ -110,6 +114,11 @@
    1516     export GS_LIB
    1617 fi
     
    2425 # Creates a directory /tmp/kde-$USER and links $KDEHOME/tmp-$HOSTNAME to it.
    2526 lnusertemp tmp >/dev/null
    26 @@ -128,7 +136,11 @@
     27@@ -128,7 +137,11 @@
    2728     # start only dcopserver, don't start whole kdeinit (takes too long)
    2829     echo 'startkde: Running kpersonalizer...'  1>&2
     
    3738     # handle kpersonalizer restarts (language change)
    3839     while test $? -eq 1; do
    39 @@ -139,7 +151,6 @@
     40@@ -139,7 +152,6 @@
    4041     sleep 1
    4142 fi
     
    4950RCS file: doc/kaddressbook/index.cache.bz2
    5051diff -N doc/kaddressbook/index.cache.bz2
    51 Binary files /dev/null and /tmp/cvs0AeqNE differ
    5252--- kate/app/Makefile.am        12 Nov 2002 04:16:41 -0000      1.1.1.4
    5353+++ kate/app/Makefile.am        26 Nov 2002 21:00:50 -0000      1.10
  • trunk/dports/x11/kdepim3/Portfile

    r1900 r1914  
    1414distfiles       ${distname}.tar.bz2 kde-admindir-20030119.tar.bz2:admin
    1515patchfiles      patch-${name}-${version}.darwin
    16 #FIXME - need to port pilot-link
    1716depends_lib     lib:libDCOP:kdelibs3 lib:libart_lgpl_2:libart_lgpl lib:libdl.1:dlcompat \
    1817                lib:libjpeg:jpeg lib:libkdecore.4:kdelibs3 bin:startkde:kdebase3 \
    19                 lib:libpng.3:libpng lib:libpoll:poll-emulator lib:libqt-mt.3.1:qt3 \
    20                 lib:libX11.6:XFree86
     18                lib:libpisock:pilot-link lib:libpng.3:libpng lib:libpoll:poll-emulator \
     19                lib:libqt-mt.3.1:qt3 lib:libX11.6:XFree86
    2120
    2221checksums       kdepim-${version}.tar.bz2 md5 9a416238193107ed2d937a3f5b02f579 \
     
    2827                        sed -e 's#@PREFIX@#${prefix}#g' '${portpath}/${filedir}/${patch}' | patch -p0"
    2928                }
     29
     30                # flex 2.5.4 (which comes with macosx) is broken
     31                # this removes the bit that messes up icalsslexer.c
     32                # we replace it below with a working .c file instead
     33                system "perl -pi -e 's,^.*/icalsslexer.c: icalssyacc.h,,' '${worksrcpath}/libical/src/libicalss/Makefile.am'"
    3034}
    31 post-patch      {
     35post-patch {
    3236                system "cd '${worksrcpath}' && cp -Rf ../admin/ admin"
    3337                system "cd '${worksrcpath}' && make -f Makefile.cvs"
     
    4145                --libexecdir='${prefix}/lib' --with-xinerama --with-pam --enable-final \
    4246                --disable-dependency-tracking
     47post-configure {
     48                system "cp '${portpath}/${filedir}/icalsslexer.c' '${worksrcpath}/libical/src/libicalss/'"
     49                system "cp '${portpath}/${filedir}/icallexer.c'   '${worksrcpath}/libical/src/libical/'"
     50}
    4351build.env       ${configure.env}
  • trunk/dports/x11/kdepim3/files/patch-kdepim3-3.1.darwin

    r1900 r1914  
    539539 
    540540 libksync_la_SOURCES = \
     541--- libical/src/Makefile.am     25 Jun 2002 03:18:23 -0000      1.1.1.1
     542+++ libical/src/Makefile.am     28 Jan 2003 21:35:09 -0000      1.2
     543@@ -4,4 +4,4 @@
     544 PYTHON_DIR =
     545 #endif
     546 
     547-SUBDIRS = libical libicalss libicalvcal $(PYTHON_DIR) test
     548+SUBDIRS = libical libicalss libicalvcal $(PYTHON_DIR)
    541549--- libical/src/libical/.cvsignore      25 Jun 2002 03:18:23 -0000      1.1.1.1
    542550+++ libical/src/libical/.cvsignore      6 Oct 2002 03:09:13 -0000       1.2
     
    562570 
    563571-icalsslexer.c
    564 RCS file: libical/src/libicalss/icalsslexer.c
    565 diff -N libical/src/libicalss/icalsslexer.c
    566 --- /dev/null   1 Jan 1970 00:00:00 -0000
    567 +++ libical/src/libicalss/icalsslexer.c 6 Oct 2002 03:39:42 -0000       1.1
    568 @@ -0,0 +1,1687 @@
    569 +/* A lexical scanner generated by flex */
    570 +
    571 +/* Scanner skeleton version:
    572 + * $Header: /Volumes/src/cvs/od/proj/KDE-Darwin/kdepim/libical/src/libicalss/icalsslexer.c,v 1.1 2002/10/06 03:39:42 ranger Exp $
    573 + */
    574 +
    575 +#define FLEX_SCANNER
    576 +#define YY_FLEX_MAJOR_VERSION 2
    577 +#define YY_FLEX_MINOR_VERSION 5
    578 +
    579 +#include <stdio.h>
    580 +
    581 +
    582 +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
    583 +#ifdef c_plusplus
    584 +#ifndef __cplusplus
    585 +#define __cplusplus
    586 +#endif
    587 +#endif
    588 +
    589 +
    590 +#ifdef __cplusplus
    591 +
    592 +#include <stdlib.h>
    593 +#include <unistd.h>
    594 +
    595 +/* Use prototypes in function declarations. */
    596 +#define YY_USE_PROTOS
    597 +
    598 +/* The "const" storage-class-modifier is valid. */
    599 +#define YY_USE_CONST
    600 +
    601 +#else  /* ! __cplusplus */
    602 +
    603 +#if __STDC__
    604 +
    605 +#define YY_USE_PROTOS
    606 +#define YY_USE_CONST
    607 +
    608 +#endif /* __STDC__ */
    609 +#endif /* ! __cplusplus */
    610 +
    611 +#ifdef __TURBOC__
    612 + #pragma warn -rch
    613 + #pragma warn -use
    614 +#include <io.h>
    615 +#include <stdlib.h>
    616 +#define YY_USE_CONST
    617 +#define YY_USE_PROTOS
    618 +#endif
    619 +
    620 +#ifdef YY_USE_CONST
    621 +#define ssconst const
    622 +#else
    623 +#define ssconst
    624 +#endif
    625 +
    626 +
    627 +#ifdef YY_USE_PROTOS
    628 +#define YY_PROTO(proto) proto
    629 +#else
    630 +#define YY_PROTO(proto) ()
    631 +#endif
    632 +
    633 +/* Returned upon end-of-file. */
    634 +#define YY_NULL 0
    635 +
    636 +/* Promotes a possibly negative, possibly signed char to an unsigned
    637 + * integer for use as an array index.  If the signed char is negative,
    638 + * we want to instead treat it as an 8-bit unsigned char, hence the
    639 + * double cast.
    640 + */
    641 +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
    642 +
    643 +/* Enter a start condition.  This macro really ought to take a parameter,
    644 + * but we do it the disgusting crufty way forced on us by the ()-less
    645 + * definition of BEGIN.
    646 + */
    647 +#define BEGIN ss_start = 1 + 2 *
    648 +
    649 +/* Translate the current start state into a value that can be later handed
    650 + * to BEGIN to return to the state.  The YYSTATE alias is for lex
    651 + * compatibility.
    652 + */
    653 +#define YY_START ((ss_start - 1) / 2)
    654 +#define YYSTATE YY_START
    655 +
    656 +/* Action number for EOF rule of a given start state. */
    657 +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
    658 +
    659 +/* Special action meaning "start processing a new file". */
    660 +#define YY_NEW_FILE ssrestart( ssin )
    661 +
    662 +#define YY_END_OF_BUFFER_CHAR 0
    663 +
    664 +/* Size of default input buffer. */
    665 +#define YY_BUF_SIZE 16384
    666 +
    667 +typedef struct ss_buffer_state *YY_BUFFER_STATE;
    668 +
    669 +extern int ssleng;
    670 +extern FILE *ssin, *ssout;
    671 +
    672 +#define EOB_ACT_CONTINUE_SCAN 0
    673 +#define EOB_ACT_END_OF_FILE 1
    674 +#define EOB_ACT_LAST_MATCH 2
    675 +
    676 +/* The funky do-while in the following #define is used to turn the definition
    677 + * int a single C statement (which needs a semi-colon terminator).  This
    678 + * avoids problems with code like:
    679 + *
    680 + *     if ( condition_holds )
    681 + *             ssless( 5 );
    682 + *     else
    683 + *             do_something_else();
    684 + *
    685 + * Prior to using the do-while the compiler would get upset at the
    686 + * "else" because it interpreted the "if" statement as being all
    687 + * done when it reached the ';' after the ssless() call.
    688 + */
    689 +
    690 +/* Return all but the first 'n' matched characters back to the input stream. */
    691 +
    692 +#define ssless(n) \
    693 +       do \
    694 +               { \
    695 +               /* Undo effects of setting up sstext. */ \
    696 +               *ss_cp = ss_hold_char; \
    697 +               YY_RESTORE_YY_MORE_OFFSET \
    698 +               ss_c_buf_p = ss_cp = ss_bp + n - YY_MORE_ADJ; \
    699 +               YY_DO_BEFORE_ACTION; /* set up sstext again */ \
    700 +               } \
    701 +       while ( 0 )
    702 +
    703 +#define unput(c) ssunput( c, sstext_ptr )
    704 +
    705 +/* The following is because we cannot portably get our hands on size_t
    706 + * (without autoconf's help, which isn't available because we want
    707 + * flex-generated scanners to compile on their own).
    708 + */
    709 +typedef unsigned int ss_size_t;
    710 +
    711 +
    712 +struct ss_buffer_state
    713 +       {
    714 +       FILE *ss_input_file;
    715 +
    716 +       char *ss_ch_buf;                /* input buffer */
    717 +       char *ss_buf_pos;               /* current position in input buffer */
    718 +
    719 +       /* Size of input buffer in bytes, not including room for EOB
    720 +        * characters.
    721 +        */
    722 +       ss_size_t ss_buf_size;
    723 +
    724 +       /* Number of characters read into ss_ch_buf, not including EOB
    725 +        * characters.
    726 +        */
    727 +       int ss_n_chars;
    728 +
    729 +       /* Whether we "own" the buffer - i.e., we know we created it,
    730 +        * and can realloc() it to grow it, and should free() it to
    731 +        * delete it.
    732 +        */
    733 +       int ss_is_our_buffer;
    734 +
    735 +       /* Whether this is an "interactive" input source; if so, and
    736 +        * if we're using stdio for input, then we want to use getc()
    737 +        * instead of fread(), to make sure we stop fetching input after
    738 +        * each newline.
    739 +        */
    740 +       int ss_is_interactive;
    741 +
    742 +       /* Whether we're considered to be at the beginning of a line.
    743 +        * If so, '^' rules will be active on the next match, otherwise
    744 +        * not.
    745 +        */
    746 +       int ss_at_bol;
    747 +
    748 +       /* Whether to try to fill the input buffer when we reach the
    749 +        * end of it.
    750 +        */
    751 +       int ss_fill_buffer;
    752 +
    753 +       int ss_buffer_status;
    754 +#define YY_BUFFER_NEW 0
    755 +#define YY_BUFFER_NORMAL 1
    756 +       /* When an EOF's been seen but there's still some text to process
    757 +        * then we mark the buffer as YY_EOF_PENDING, to indicate that we
    758 +        * shouldn't try reading from the input source any more.  We might
    759 +        * still have a bunch of tokens to match, though, because of
    760 +        * possible backing-up.
    761 +        *
    762 +        * When we actually see the EOF, we change the status to "new"
    763 +        * (via ssrestart()), so that the user can continue scanning by
    764 +        * just pointing ssin at a new input file.
    765 +        */
    766 +#define YY_BUFFER_EOF_PENDING 2
    767 +       };
    768 +
    769 +static YY_BUFFER_STATE ss_current_buffer = 0;
    770 +
    771 +/* We provide macros for accessing buffer states in case in the
    772 + * future we want to put the buffer states in a more general
    773 + * "scanner state".
    774 + */
    775 +#define YY_CURRENT_BUFFER ss_current_buffer
    776 +
    777 +
    778 +/* ss_hold_char holds the character lost when sstext is formed. */
    779 +static char ss_hold_char;
    780 +
    781 +static int ss_n_chars;         /* number of characters read into ss_ch_buf */
    782 +
    783 +
    784 +int ssleng;
    785 +
    786 +/* Points to current character in buffer. */
    787 +static char *ss_c_buf_p = (char *) 0;
    788 +static int ss_init = 1;                /* whether we need to initialize */
    789 +static int ss_start = 0;       /* start state number */
    790 +
    791 +/* Flag which is used to allow sswrap()'s to do buffer switches
    792 + * instead of setting up a fresh ssin.  A bit of a hack ...
    793 + */
    794 +static int ss_did_buffer_switch_on_eof;
    795 +
    796 +void ssrestart YY_PROTO(( FILE *input_file ));
    797 +
    798 +void ss_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
    799 +void ss_load_buffer_state YY_PROTO(( void ));
    800 +YY_BUFFER_STATE ss_create_buffer YY_PROTO(( FILE *file, int size ));
    801 +void ss_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
    802 +void ss_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
    803 +void ss_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
    804 +#define YY_FLUSH_BUFFER ss_flush_buffer( ss_current_buffer )
    805 +
    806 +YY_BUFFER_STATE ss_scan_buffer YY_PROTO(( char *base, ss_size_t size ));
    807 +YY_BUFFER_STATE ss_scan_string YY_PROTO(( ssconst char *ss_str ));
    808 +YY_BUFFER_STATE ss_scan_bytes YY_PROTO(( ssconst char *bytes, int len ));
    809 +
    810 +static void *ss_flex_alloc YY_PROTO(( ss_size_t ));
    811 +static void *ss_flex_realloc YY_PROTO(( void *, ss_size_t ));
    812 +static void ss_flex_free YY_PROTO(( void * ));
    813 +
    814 +#define ss_new_buffer ss_create_buffer
    815 +
    816 +#define ss_set_interactive(is_interactive) \
    817 +       { \
    818 +       if ( ! ss_current_buffer ) \
    819 +               ss_current_buffer = ss_create_buffer( ssin, YY_BUF_SIZE ); \
    820 +       ss_current_buffer->ss_is_interactive = is_interactive; \
    821 +       }
    822 +
    823 +#define ss_set_bol(at_bol) \
    824 +       { \
    825 +       if ( ! ss_current_buffer ) \
    826 +               ss_current_buffer = ss_create_buffer( ssin, YY_BUF_SIZE ); \
    827 +       ss_current_buffer->ss_at_bol = at_bol; \
    828 +       }
    829 +
    830 +#define YY_AT_BOL() (ss_current_buffer->ss_at_bol)
    831 +
    832 +typedef unsigned char YY_CHAR;
    833 +FILE *ssin = (FILE *) 0, *ssout = (FILE *) 0;
    834 +typedef int ss_state_type;
    835 +extern char sstext[];
    836 +
    837 +
    838 +static ss_state_type ss_get_previous_state YY_PROTO(( void ));
    839 +static ss_state_type ss_try_NUL_trans YY_PROTO(( ss_state_type current_state ));
    840 +static int ss_get_next_buffer YY_PROTO(( void ));
    841 +static void ss_fatal_error YY_PROTO(( ssconst char msg[] ));
    842 +
    843 +/* Done after the current pattern has been matched and before the
    844 + * corresponding action - sets up sstext.
    845 + */
    846 +#define YY_DO_BEFORE_ACTION \
    847 +       sstext_ptr = ss_bp; \
    848 +       ssleng = (int) (ss_cp - ss_bp); \
    849 +       ss_hold_char = *ss_cp; \
    850 +       *ss_cp = '\0'; \
    851 +       if ( ssleng >= YYLMAX ) \
    852 +               YY_FATAL_ERROR( "token too large, exceeds YYLMAX" ); \
    853 +       ss_flex_strncpy( sstext, sstext_ptr, ssleng + 1 ); \
    854 +       ss_c_buf_p = ss_cp;
    855 +
    856 +#define YY_NUM_RULES 19
    857 +#define YY_END_OF_BUFFER 20
    858 +static ssconst short int ss_accept[47] =
    859 +    {   0,
    860 +        0,    0,    0,    0,    0,    0,   20,   18,   14,   14,
    861 +       18,   13,   17,    4,   15,    7,    5,    8,   17,   17,
    862 +       17,   17,   17,   14,    6,    0,   17,    9,   10,   17,
    863 +       17,   12,   17,   17,   16,   11,   17,   17,   17,    2,
    864 +       17,   17,   17,    3,    1,    0
    865 +    } ;
    866 +
    867 +static ssconst int ss_ec[256] =
    868 +    {   0,
    869 +        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
    870 +        1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
    871 +        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    872 +        1,    2,    4,    1,    1,    1,    1,    1,    5,    1,
    873 +        1,    6,    1,    7,    6,    6,    1,    6,    6,    6,
    874 +        6,    6,    6,    6,    6,    6,    6,    1,    8,    9,
    875 +       10,   11,    1,    1,   12,    6,   13,   14,   15,   16,
    876 +        6,   17,    6,    6,    6,   18,   19,   20,   21,    6,
    877 +        6,   22,   23,   24,    6,    6,   25,    6,    6,    6,
    878 +        1,    1,    1,    1,    1,    1,   12,    6,   13,   14,
    879 +
    880 +       15,   16,    6,   17,    6,    6,    6,   18,   19,   20,
    881 +       21,    6,    6,   22,   23,   24,    6,    6,   25,    6,
    882 +        6,    6,    1,    1,    1,    1,    1,    1,    1,    1,
    883 +        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    884 +        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    885 +        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    886 +        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    887 +        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    888 +        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    889 +        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    890 +
    891 +        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    892 +        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    893 +        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    894 +        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    895 +        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    896 +        1,    1,    1,    1,    1
    897 +    } ;
    898 +
    899 +static ssconst int ss_meta[26] =
    900 +    {   0,
    901 +        1,    1,    1,    1,    1,    2,    1,    1,    1,    1,
    902 +        1,    2,    2,    2,    2,    2,    2,    2,    2,    2,
    903 +        2,    2,    2,    2,    2
    904 +    } ;
    905 +
    906 +static ssconst short int ss_base[49] =
    907 +    {   0,
    908 +        0,    0,    0,    0,    0,    0,   53,   54,   24,   26,
    909 +       42,    0,    0,   54,   54,   41,   54,   40,   29,   26,
    910 +       25,   31,   28,   28,   54,   39,    0,   54,   54,   29,
    911 +       21,    0,   23,   25,   54,    0,   20,   23,   15,    0,
    912 +       23,   20,   10,    0,    0,   54,   31,   30
    913 +    } ;
    914 +
    915 +static ssconst short int ss_def[49] =
    916 +    {   0,
    917 +       46,    1,    1,    1,    1,    1,   46,   46,   46,   46,
    918 +       46,   47,   48,   46,   46,   46,   46,   46,   48,   48,
    919 +       48,   48,   48,   46,   46,   47,   48,   46,   46,   48,
    920 +       48,   48,   48,   48,   46,   48,   48,   48,   48,   48,
    921 +       48,   48,   48,   48,   48,    0,   46,   46
    922 +    } ;
    923 +
    924 +static ssconst short int ss_nxt[80] =
    925 +    {   0,
    926 +        8,    9,   10,   11,   12,   13,   14,   15,   16,   17,
    927 +       18,   19,   13,   13,   13,   20,   13,   13,   13,   13,
    928 +       21,   13,   22,   13,   23,   24,   24,   24,   24,   24,
    929 +       24,   27,   26,   45,   44,   43,   42,   41,   40,   39,
    930 +       38,   37,   36,   35,   34,   33,   32,   31,   30,   29,
    931 +       28,   25,   46,    7,   46,   46,   46,   46,   46,   46,
    932 +       46,   46,   46,   46,   46,   46,   46,   46,   46,   46,
    933 +       46,   46,   46,   46,   46,   46,   46,   46,   46
    934 +    } ;
    935 +
    936 +static ssconst short int ss_chk[80] =
    937 +    {   0,
    938 +        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    939 +        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    940 +        1,    1,    1,    1,    1,    9,    9,   10,   10,   24,
    941 +       24,   48,   47,   43,   42,   41,   39,   38,   37,   34,
    942 +       33,   31,   30,   26,   23,   22,   21,   20,   19,   18,
    943 +       16,   11,    7,   46,   46,   46,   46,   46,   46,   46,
    944 +       46,   46,   46,   46,   46,   46,   46,   46,   46,   46,
    945 +       46,   46,   46,   46,   46,   46,   46,   46,   46
    946 +    } ;
    947 +
    948 +static ss_state_type ss_last_accepting_state;
    949 +static char *ss_last_accepting_cpos;
    950 +
    951 +/* The intent behind this definition is that it'll catch
    952 + * any uses of REJECT which flex missed.
    953 + */
    954 +#define REJECT reject_used_but_not_detected
    955 +#define ssmore() ssmore_used_but_not_detected
    956 +#define YY_MORE_ADJ 0
    957 +#define YY_RESTORE_YY_MORE_OFFSET
    958 +#ifndef YYLMAX
    959 +#define YYLMAX 8192
    960 +#endif
    961 +
    962 +char sstext[YYLMAX];
    963 +char *sstext_ptr;
    964 +#line 1 "icalsslexer.l"
    965 +#define INITIAL 0
    966 +#line 2 "icalsslexer.l"
    967 +/* -*- Mode: C -*-
    968 +  ======================================================================
    969 +  FILE: icalsslexer.l
    970 +  CREATOR: eric 8 Aug 2000
    971 
    972 +  DESCRIPTION:
    973 
    974 +  $Id: icalsslexer.c,v 1.1 2002/10/06 03:39:42 ranger Exp $
    975 +  $Locker:  $
    976 +
    977 +(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
    978 +
    979 + This program is free software; you can redistribute it and/or modify
    980 + it under the terms of either:
    981 +
    982 +    The LGPL as published by the Free Software Foundation, version
    983 +    2.1, available at: http://www.fsf.org/copyleft/lesser.html
    984 +
    985 +  Or:
    986 +
    987 +    The Mozilla Public License Version 1.0. You may obtain a copy of
    988 +    the License at http://www.mozilla.org/MPL/
    989 +
    990 + The Original Code is eric. The Initial Developer of the Original
    991 + Code is Eric Busboom
    992 +
    993 +  ======================================================================*/
    994 +
    995 +#include "icalssyacc.h"
    996 +#include "icalgaugeimpl.h"
    997 +#include "assert.h"
    998 +
    999 +#include <string.h> /* For strdup() */
    1000 +
    1001 +int icalparser_flex_input(char* buf, int max_size);
    1002 +void icalparser_clear_flex_input();
    1003 +
    1004 +#undef YY_INPUT
    1005 +#define YY_INPUT(b,r,ms) ( r= icalparser_flex_input(b,ms))
    1006 +
    1007 +#undef SS_FATAL_ERROR
    1008 +#define SS_FATAL_ERROR(msg) sserror(msg)
    1009 +
    1010 +
    1011 +#define sql 1
    1012 +#define string_value 2
    1013 +
    1014 +#line 465 "icalsslexer.c"
    1015 +
    1016 +/* Macros after this point can all be overridden by user definitions in
    1017 + * section 1.
    1018 + */
    1019 +
    1020 +#ifndef YY_SKIP_YYWRAP
    1021 +#ifdef __cplusplus
    1022 +extern "C" int sswrap YY_PROTO(( void ));
    1023 +#else
    1024 +extern int sswrap YY_PROTO(( void ));
    1025 +#endif
    1026 +#endif
    1027 +
    1028 +#ifndef YY_NO_UNPUT
    1029 +static void ssunput YY_PROTO(( int c, char *buf_ptr ));
    1030 +#endif
    1031 +
    1032 +#ifndef sstext_ptr
    1033 +static void ss_flex_strncpy YY_PROTO(( char *, ssconst char *, int ));
    1034 +#endif
    1035 +
    1036 +#ifdef YY_NEED_STRLEN
    1037 +static int ss_flex_strlen YY_PROTO(( ssconst char * ));
    1038 +#endif
    1039 +
    1040 +#ifndef YY_NO_INPUT
    1041 +#ifdef __cplusplus
    1042 +static int ssinput YY_PROTO(( void ));
    1043 +#else
    1044 +static int input YY_PROTO(( void ));
    1045 +#endif
    1046 +#endif
    1047 +
    1048 +#if YY_STACK_USED
    1049 +static int ss_start_stack_ptr = 0;
    1050 +static int ss_start_stack_depth = 0;
    1051 +static int *ss_start_stack = 0;
    1052 +#ifndef YY_NO_PUSH_STATE
    1053 +static void ss_push_state YY_PROTO(( int new_state ));
    1054 +#endif
    1055 +#ifndef YY_NO_POP_STATE
    1056 +static void ss_pop_state YY_PROTO(( void ));
    1057 +#endif
    1058 +#ifndef YY_NO_TOP_STATE
    1059 +static int ss_top_state YY_PROTO(( void ));
    1060 +#endif
    1061 +
    1062 +#else
    1063 +#define YY_NO_PUSH_STATE 1
    1064 +#define YY_NO_POP_STATE 1
    1065 +#define YY_NO_TOP_STATE 1
    1066 +#endif
    1067 +
    1068 +#ifdef YY_MALLOC_DECL
    1069 +YY_MALLOC_DECL
    1070 +#else
    1071 +#if __STDC__
    1072 +#ifndef __cplusplus
    1073 +#include <stdlib.h>
    1074 +#endif
    1075 +#else
    1076 +/* Just try to get by without declaring the routines.  This will fail
    1077 + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
    1078 + * or sizeof(void*) != sizeof(int).
    1079 + */
    1080 +#endif
    1081 +#endif
    1082 +
    1083 +/* Amount of stuff to slurp up with each read. */
    1084 +#ifndef YY_READ_BUF_SIZE
    1085 +#define YY_READ_BUF_SIZE 8192
    1086 +#endif
    1087 +
    1088 +/* Copy whatever the last rule matched to the standard output. */
    1089 +
    1090 +#ifndef ECHO
    1091 +/* This used to be an fputs(), but since the string might contain NUL's,
    1092 + * we now use fwrite().
    1093 + */
    1094 +#define ECHO (void) fwrite( sstext, ssleng, 1, ssout )
    1095 +#endif
    1096 +
    1097 +/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
    1098 + * is returned in "result".
    1099 + */
    1100 +#ifndef YY_INPUT
    1101 +#define YY_INPUT(buf,result,max_size) \
    1102 +       if ( ss_current_buffer->ss_is_interactive ) \
    1103 +               { \
    1104 +               int c = '*', n; \
    1105 +               for ( n = 0; n < max_size && \
    1106 +                            (c = getc( ssin )) != EOF && c != '\n'; ++n ) \
    1107 +                       buf[n] = (char) c; \
    1108 +               if ( c == '\n' ) \
    1109 +                       buf[n++] = (char) c; \
    1110 +               if ( c == EOF && ferror( ssin ) ) \
    1111 +                       YY_FATAL_ERROR( "input in flex scanner failed" ); \
    1112 +               result = n; \
    1113 +               } \
    1114 +       else if ( ((result = fread( buf, 1, max_size, ssin )) == 0) \
    1115 +                 && ferror( ssin ) ) \
    1116 +               YY_FATAL_ERROR( "input in flex scanner failed" );
    1117 +#endif
    1118 +
    1119 +/* No semi-colon after return; correct usage is to write "ssterminate();" -
    1120 + * we don't want an extra ';' after the "return" because that will cause
    1121 + * some compilers to complain about unreachable statements.
    1122 + */
    1123 +#ifndef ssterminate
    1124 +#define ssterminate() return YY_NULL
    1125 +#endif
    1126 +
    1127 +/* Number of entries by which start-condition stack grows. */
    1128 +#ifndef YY_START_STACK_INCR
    1129 +#define YY_START_STACK_INCR 25
    1130 +#endif
    1131 +
    1132 +/* Report a fatal error. */
    1133 +#ifndef YY_FATAL_ERROR
    1134 +#define YY_FATAL_ERROR(msg) ss_fatal_error( msg )
    1135 +#endif
    1136 +
    1137 +/* Default declaration of generated scanner - a define so the user can
    1138 + * easily add parameters.
    1139 + */
    1140 +#ifndef YY_DECL
    1141 +#define YY_DECL int sslex YY_PROTO(( void ))
    1142 +#endif
    1143 +
    1144 +/* Code executed at the beginning of each rule, after sstext and ssleng
    1145 + * have been set up.
    1146 + */
    1147 +#ifndef YY_USER_ACTION
    1148 +#define YY_USER_ACTION
    1149 +#endif
    1150 +
    1151 +/* Code executed at the end of each rule. */
    1152 +#ifndef YY_BREAK
    1153 +#define YY_BREAK break;
    1154 +#endif
    1155 +
    1156 +#define YY_RULE_SETUP \
    1157 +       YY_USER_ACTION
    1158 +
    1159 +YY_DECL
    1160 +       {
    1161 +       register ss_state_type ss_current_state;
    1162 +       register char *ss_cp, *ss_bp;
    1163 +       register int ss_act;
    1164 +
    1165 +#line 69 "icalsslexer.l"
    1166 +
    1167 +
    1168 +
    1169 +
    1170 +
    1171 +
    1172 +#line 623 "icalsslexer.c"
    1173 +
    1174 +       if ( ss_init )
    1175 +               {
    1176 +               ss_init = 0;
    1177 +
    1178 +#ifdef YY_USER_INIT
    1179 +               YY_USER_INIT;
    1180 +#endif
    1181 +
    1182 +               if ( ! ss_start )
    1183 +                       ss_start = 1;   /* first start state */
    1184 +
    1185 +               if ( ! ssin )
    1186 +                       ssin = stdin;
    1187 +
    1188 +               if ( ! ssout )
    1189 +                       ssout = stdout;
    1190 +
    1191 +               if ( ! ss_current_buffer )
    1192 +                       ss_current_buffer =
    1193 +                               ss_create_buffer( ssin, YY_BUF_SIZE );
    1194 +
    1195 +               ss_load_buffer_state();
    1196 +               }
    1197 +
    1198 +       while ( 1 )             /* loops until end-of-file is reached */
    1199 +               {
    1200 +               ss_cp = ss_c_buf_p;
    1201 +
    1202 +               /* Support of sstext. */
    1203 +               *ss_cp = ss_hold_char;
    1204 +
    1205 +               /* ss_bp points to the position in ss_ch_buf of the start of
    1206 +                * the current run.
    1207 +                */
    1208 +               ss_bp = ss_cp;
    1209 +
    1210 +               ss_current_state = ss_start;
    1211 +ss_match:
    1212 +               do
    1213 +                       {
    1214 +                       register YY_CHAR ss_c = ss_ec[YY_SC_TO_UI(*ss_cp)];
    1215 +                       if ( ss_accept[ss_current_state] )
    1216 +                               {
    1217 +                               ss_last_accepting_state = ss_current_state;
    1218 +                               ss_last_accepting_cpos = ss_cp;
    1219 +                               }
    1220 +                       while ( ss_chk[ss_base[ss_current_state] + ss_c] != ss_current_state )
    1221 +                               {
    1222 +                               ss_current_state = (int) ss_def[ss_current_state];
    1223 +                               if ( ss_current_state >= 47 )
    1224 +                                       ss_c = ss_meta[(unsigned int) ss_c];
    1225 +                               }
    1226 +                       ss_current_state = ss_nxt[ss_base[ss_current_state] + (unsigned int) ss_c];
    1227 +                       ++ss_cp;
    1228 +                       }
    1229 +               while ( ss_base[ss_current_state] != 54 );
    1230 +
    1231 +ss_find_action:
    1232 +               ss_act = ss_accept[ss_current_state];
    1233 +               if ( ss_act == 0 )
    1234 +                       { /* have to back up */
    1235 +                       ss_cp = ss_last_accepting_cpos;
    1236 +                       ss_current_state = ss_last_accepting_state;
    1237 +                       ss_act = ss_accept[ss_current_state];
    1238 +                       }
    1239 +
    1240 +               YY_DO_BEFORE_ACTION;
    1241 +
    1242 +
    1243 +do_action:     /* This label is used only to access EOF actions. */
    1244 +
    1245 +
    1246 +               switch ( ss_act )
    1247 +       { /* beginning of action switch */
    1248 +                       case 0: /* must back up */
    1249 +                       /* undo the effects of YY_DO_BEFORE_ACTION */
    1250 +                       *ss_cp = ss_hold_char;
    1251 +                       ss_cp = ss_last_accepting_cpos;
    1252 +                       ss_current_state = ss_last_accepting_state;
    1253 +                       goto ss_find_action;
    1254 +
    1255 +case 1:
    1256 +YY_RULE_SETUP
    1257 +#line 75 "icalsslexer.l"
    1258 +{ return SELECT; }
    1259 +       YY_BREAK
    1260 +case 2:
    1261 +YY_RULE_SETUP
    1262 +#line 76 "icalsslexer.l"
    1263 +{ return FROM; }
    1264 +       YY_BREAK
    1265 +case 3:
    1266 +YY_RULE_SETUP
    1267 +#line 77 "icalsslexer.l"
    1268 +{ return WHERE; }
    1269 +       YY_BREAK
    1270 +case 4:
    1271 +YY_RULE_SETUP
    1272 +#line 78 "icalsslexer.l"
    1273 +{ return COMMA; }
    1274 +       YY_BREAK
    1275 +case 5:
    1276 +YY_RULE_SETUP
    1277 +#line 79 "icalsslexer.l"
    1278 +{ return EQUALS; }
    1279 +       YY_BREAK
    1280 +case 6:
    1281 +YY_RULE_SETUP
    1282 +#line 80 "icalsslexer.l"
    1283 +{ return NOTEQUALS; }
    1284 +       YY_BREAK
    1285 +case 7:
    1286 +YY_RULE_SETUP
    1287 +#line 81 "icalsslexer.l"
    1288 +{ return LESS; }
    1289 +       YY_BREAK
    1290 +case 8:
    1291 +YY_RULE_SETUP
    1292 +#line 82 "icalsslexer.l"
    1293 +{ return GREATER; }
    1294 +       YY_BREAK
    1295 +case 9:
    1296 +YY_RULE_SETUP
    1297 +#line 83 "icalsslexer.l"
    1298 +{ return LESSEQUALS; }
    1299 +       YY_BREAK
    1300 +case 10:
    1301 +YY_RULE_SETUP
    1302 +#line 84 "icalsslexer.l"
    1303 +{ return GREATEREQUALS; }
    1304 +       YY_BREAK
    1305 +case 11:
    1306 +YY_RULE_SETUP
    1307 +#line 85 "icalsslexer.l"
    1308 +{ return AND; }
    1309 +       YY_BREAK
    1310 +case 12:
    1311 +YY_RULE_SETUP
    1312 +#line 86 "icalsslexer.l"
    1313 +{ return OR; }
    1314 +       YY_BREAK
    1315 +case 13:
    1316 +YY_RULE_SETUP
    1317 +#line 87 "icalsslexer.l"
    1318 +{ return QUOTE; }
    1319 +       YY_BREAK
    1320 +case 14:
    1321 +YY_RULE_SETUP
    1322 +#line 88 "icalsslexer.l"
    1323 +;                     
    1324 +       YY_BREAK
    1325 +case 15:
    1326 +YY_RULE_SETUP
    1327 +#line 89 "icalsslexer.l"
    1328 +{ return EOL; }
    1329 +       YY_BREAK
    1330 +case 16:
    1331 +YY_RULE_SETUP
    1332 +#line 90 "icalsslexer.l"
    1333 +{
    1334 +       int c = input();
    1335 +       unput(c);
    1336 +       if(c!='\''){
    1337 +               sslval.v_string= icalmemory_tmp_copy(sstext);
    1338 +               return STRING;
    1339 +       } else {
    1340 +               /*ssmore();*/
    1341 +       }
    1342 +}
    1343 +       YY_BREAK
    1344 +case 17:
    1345 +YY_RULE_SETUP
    1346 +#line 101 "icalsslexer.l"
    1347 +{ sslval.v_string= icalmemory_tmp_copy(sstext);
    1348 +                         return STRING; }
    1349 +       YY_BREAK
    1350 +case 18:
    1351 +YY_RULE_SETUP
    1352 +#line 105 "icalsslexer.l"
    1353 +{ return sstext[0]; }
    1354 +       YY_BREAK
    1355 +case 19:
    1356 +YY_RULE_SETUP
    1357 +#line 107 "icalsslexer.l"
    1358 +ECHO;
    1359 +       YY_BREAK
    1360 +#line 811 "icalsslexer.c"
    1361 +case YY_STATE_EOF(INITIAL):
    1362 +case YY_STATE_EOF(sql):
    1363 +case YY_STATE_EOF(string_value):
    1364 +       ssterminate();
    1365 +
    1366 +       case YY_END_OF_BUFFER:
    1367 +               {
    1368 +               /* Amount of text matched not including the EOB char. */
    1369 +               int ss_amount_of_matched_text = (int) (ss_cp - sstext_ptr) - 1;
    1370 +
    1371 +               /* Undo the effects of YY_DO_BEFORE_ACTION. */
    1372 +               *ss_cp = ss_hold_char;
    1373 +               YY_RESTORE_YY_MORE_OFFSET
    1374 +
    1375 +               if ( ss_current_buffer->ss_buffer_status == YY_BUFFER_NEW )
    1376 +                       {
    1377 +                       /* We're scanning a new file or input source.  It's
    1378 +                        * possible that this happened because the user
    1379 +                        * just pointed ssin at a new source and called
    1380 +                        * sslex().  If so, then we have to assure
    1381 +                        * consistency between ss_current_buffer and our
    1382 +                        * globals.  Here is the right place to do so, because
    1383 +                        * this is the first action (other than possibly a
    1384 +                        * back-up) that will match for the new input source.
    1385 +                        */
    1386 +                       ss_n_chars = ss_current_buffer->ss_n_chars;
    1387 +                       ss_current_buffer->ss_input_file = ssin;
    1388 +                       ss_current_buffer->ss_buffer_status = YY_BUFFER_NORMAL;
    1389 +                       }
    1390 +
    1391 +               /* Note that here we test for ss_c_buf_p "<=" to the position
    1392 +                * of the first EOB in the buffer, since ss_c_buf_p will
    1393 +                * already have been incremented past the NUL character
    1394 +                * (since all states make transitions on EOB to the
    1395 +                * end-of-buffer state).  Contrast this with the test
    1396 +                * in input().
    1397 +                */
    1398 +               if ( ss_c_buf_p <= &ss_current_buffer->ss_ch_buf[ss_n_chars] )
    1399 +                       { /* This was really a NUL. */
    1400 +                       ss_state_type ss_next_state;
    1401 +
    1402 +                       ss_c_buf_p = sstext_ptr + ss_amount_of_matched_text;
    1403 +
    1404 +                       ss_current_state = ss_get_previous_state();
    1405 +
    1406 +                       /* Okay, we're now positioned to make the NUL
    1407 +                        * transition.  We couldn't have
    1408 +                        * ss_get_previous_state() go ahead and do it
    1409 +                        * for us because it doesn't know how to deal
    1410 +                        * with the possibility of jamming (and we don't
    1411 +                        * want to build jamming into it because then it
    1412 +                        * will run more slowly).
    1413 +                        */
    1414 +
    1415 +                       ss_next_state = ss_try_NUL_trans( ss_current_state );
    1416 +
    1417 +                       ss_bp = sstext_ptr + YY_MORE_ADJ;
    1418 +
    1419 +                       if ( ss_next_state )
    1420 +                               {
    1421 +                               /* Consume the NUL. */
    1422 +                               ss_cp = ++ss_c_buf_p;
    1423 +                               ss_current_state = ss_next_state;
    1424 +                               goto ss_match;
    1425 +                               }
    1426 +
    1427 +                       else
    1428 +                               {
    1429 +                               ss_cp = ss_c_buf_p;
    1430 +                               goto ss_find_action;
    1431 +                               }
    1432 +                       }
    1433 +
    1434 +               else switch ( ss_get_next_buffer() )
    1435 +                       {
    1436 +                       case EOB_ACT_END_OF_FILE:
    1437 +                               {
    1438 +                               ss_did_buffer_switch_on_eof = 0;
    1439 +
    1440 +                               if ( sswrap() )
    1441 +                                       {
    1442 +                                       /* Note: because we've taken care in
    1443 +                                        * ss_get_next_buffer() to have set up
    1444 +                                        * sstext, we can now set up
    1445 +                                        * ss_c_buf_p so that if some total
    1446 +                                        * hoser (like flex itself) wants to
    1447 +                                        * call the scanner after we return the
    1448 +                                        * YY_NULL, it'll still work - another
    1449 +                                        * YY_NULL will get returned.
    1450 +                                        */
    1451 +                                       ss_c_buf_p = sstext_ptr + YY_MORE_ADJ;
    1452 +
    1453 +                                       ss_act = YY_STATE_EOF(YY_START);
    1454 +                                       goto do_action;
    1455 +                                       }
    1456 +
    1457 +                               else
    1458 +                                       {
    1459 +                                       if ( ! ss_did_buffer_switch_on_eof )
    1460 +                                               YY_NEW_FILE;
    1461 +                                       }
    1462 +                               break;
    1463 +                               }
    1464 +
    1465 +                       case EOB_ACT_CONTINUE_SCAN:
    1466 +                               ss_c_buf_p =
    1467 +                                       sstext_ptr + ss_amount_of_matched_text;
    1468 +
    1469 +                               ss_current_state = ss_get_previous_state();
    1470 +
    1471 +                               ss_cp = ss_c_buf_p;
    1472 +                               ss_bp = sstext_ptr + YY_MORE_ADJ;
    1473 +                               goto ss_match;
    1474 +
    1475 +                       case EOB_ACT_LAST_MATCH:
    1476 +                               ss_c_buf_p =
    1477 +                               &ss_current_buffer->ss_ch_buf[ss_n_chars];
    1478 +
    1479 +                               ss_current_state = ss_get_previous_state();
    1480 +
    1481 +                               ss_cp = ss_c_buf_p;
    1482 +                               ss_bp = sstext_ptr + YY_MORE_ADJ;
    1483 +                               goto ss_find_action;
    1484 +                       }
    1485 +               break;
    1486 +               }
    1487 +
    1488 +       default:
    1489 +               YY_FATAL_ERROR(
    1490 +                       "fatal flex scanner internal error--no action found" );
    1491 +       } /* end of action switch */
    1492 +               } /* end of scanning one token */
    1493 +       } /* end of sslex */
    1494 +
    1495 +
    1496 +/* ss_get_next_buffer - try to read in a new buffer
    1497 + *
    1498 + * Returns a code representing an action:
    1499 + *     EOB_ACT_LAST_MATCH -
    1500 + *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
    1501 + *     EOB_ACT_END_OF_FILE - end of file
    1502 + */
    1503 +
    1504 +static int ss_get_next_buffer()
    1505 +       {
    1506 +       register char *dest = ss_current_buffer->ss_ch_buf;
    1507 +       register char *source = sstext_ptr;
    1508 +       register int number_to_move, i;
    1509 +       int ret_val;
    1510 +
    1511 +       if ( ss_c_buf_p > &ss_current_buffer->ss_ch_buf[ss_n_chars + 1] )
    1512 +               YY_FATAL_ERROR(
    1513 +               "fatal flex scanner internal error--end of buffer missed" );
    1514 +
    1515 +       if ( ss_current_buffer->ss_fill_buffer == 0 )
    1516 +               { /* Don't try to fill the buffer, so this is an EOF. */
    1517 +               if ( ss_c_buf_p - sstext_ptr - YY_MORE_ADJ == 1 )
    1518 +                       {
    1519 +                       /* We matched a single character, the EOB, so
    1520 +                        * treat this as a final EOF.
    1521 +                        */
    1522 +                       return EOB_ACT_END_OF_FILE;
    1523 +                       }
    1524 +
    1525 +               else
    1526 +                       {
    1527 +                       /* We matched some text prior to the EOB, first
    1528 +                        * process it.
    1529 +                        */
    1530 +                       return EOB_ACT_LAST_MATCH;
    1531 +                       }
    1532 +               }
    1533 +
    1534 +       /* Try to read more data. */
    1535 +
    1536 +       /* First move last chars to start of buffer. */
    1537 +       number_to_move = (int) (ss_c_buf_p - sstext_ptr) - 1;
    1538 +
    1539 +       for ( i = 0; i < number_to_move; ++i )
    1540 +               *(dest++) = *(source++);
    1541 +
    1542 +       if ( ss_current_buffer->ss_buffer_status == YY_BUFFER_EOF_PENDING )
    1543 +               /* don't do the read, it's not guaranteed to return an EOF,
    1544 +                * just force an EOF
    1545 +                */
    1546 +               ss_current_buffer->ss_n_chars = ss_n_chars = 0;
    1547 +
    1548 +       else
    1549 +               {
    1550 +               int num_to_read =
    1551 +                       ss_current_buffer->ss_buf_size - number_to_move - 1;
    1552 +
    1553 +               while ( num_to_read <= 0 )
    1554 +                       { /* Not enough room in the buffer - grow it. */
    1555 +#ifdef YY_USES_REJECT
    1556 +                       YY_FATAL_ERROR(
    1557 +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
    1558 +#else
    1559 +
    1560 +                       /* just a shorter name for the current buffer */
    1561 +                       YY_BUFFER_STATE b = ss_current_buffer;
    1562 +
    1563 +                       int ss_c_buf_p_offset =
    1564 +                               (int) (ss_c_buf_p - b->ss_ch_buf);
    1565 +
    1566 +                       if ( b->ss_is_our_buffer )
    1567 +                               {
    1568 +                               int new_size = b->ss_buf_size * 2;
    1569 +
    1570 +                               if ( new_size <= 0 )
    1571 +                                       b->ss_buf_size += b->ss_buf_size / 8;
    1572 +                               else
    1573 +                                       b->ss_buf_size *= 2;
    1574 +
    1575 +                               b->ss_ch_buf = (char *)
    1576 +                                       /* Include room in for 2 EOB chars. */
    1577 +                                       ss_flex_realloc( (void *) b->ss_ch_buf,
    1578 +                                                        b->ss_buf_size + 2 );
    1579 +                               }
    1580 +                       else
    1581 +                               /* Can't grow it, we don't own it. */
    1582 +                               b->ss_ch_buf = 0;
    1583 +
    1584 +                       if ( ! b->ss_ch_buf )
    1585 +                               YY_FATAL_ERROR(
    1586 +                               "fatal error - scanner input buffer overflow" );
    1587 +
    1588 +                       ss_c_buf_p = &b->ss_ch_buf[ss_c_buf_p_offset];
    1589 +
    1590 +                       num_to_read = ss_current_buffer->ss_buf_size -
    1591 +                                               number_to_move - 1;
    1592 +#endif
    1593 +                       }
    1594 +
    1595 +               if ( num_to_read > YY_READ_BUF_SIZE )
    1596 +                       num_to_read = YY_READ_BUF_SIZE;
    1597 +
    1598 +               /* Read in more data. */
    1599 +               YY_INPUT( (&ss_current_buffer->ss_ch_buf[number_to_move]),
    1600 +                       ss_n_chars, num_to_read );
    1601 +
    1602 +               ss_current_buffer->ss_n_chars = ss_n_chars;
    1603 +               }
    1604 +
    1605 +       if ( ss_n_chars == 0 )
    1606 +               {
    1607 +               if ( number_to_move == YY_MORE_ADJ )
    1608 +                       {
    1609 +                       ret_val = EOB_ACT_END_OF_FILE;
    1610 +                       ssrestart( ssin );
    1611 +                       }
    1612 +
    1613 +               else
    1614 +                       {
    1615 +                       ret_val = EOB_ACT_LAST_MATCH;
    1616 +                       ss_current_buffer->ss_buffer_status =
    1617 +                               YY_BUFFER_EOF_PENDING;
    1618 +                       }
    1619 +               }
    1620 +
    1621 +       else
    1622 +               ret_val = EOB_ACT_CONTINUE_SCAN;
    1623 +
    1624 +       ss_n_chars += number_to_move;
    1625 +       ss_current_buffer->ss_ch_buf[ss_n_chars] = YY_END_OF_BUFFER_CHAR;
    1626 +       ss_current_buffer->ss_ch_buf[ss_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
    1627 +
    1628 +       sstext_ptr = &ss_current_buffer->ss_ch_buf[0];
    1629 +
    1630 +       return ret_val;
    1631 +       }
    1632 +
    1633 +
    1634 +/* ss_get_previous_state - get the state just before the EOB char was reached */
    1635 +
    1636 +static ss_state_type ss_get_previous_state()
    1637 +       {
    1638 +       register ss_state_type ss_current_state;
    1639 +       register char *ss_cp;
    1640 +
    1641 +       ss_current_state = ss_start;
    1642 +
    1643 +       for ( ss_cp = sstext_ptr + YY_MORE_ADJ; ss_cp < ss_c_buf_p; ++ss_cp )
    1644 +               {
    1645 +               register YY_CHAR ss_c = (*ss_cp ? ss_ec[YY_SC_TO_UI(*ss_cp)] : 1);
    1646 +               if ( ss_accept[ss_current_state] )
    1647 +                       {
    1648 +                       ss_last_accepting_state = ss_current_state;
    1649 +                       ss_last_accepting_cpos = ss_cp;
    1650 +                       }
    1651 +               while ( ss_chk[ss_base[ss_current_state] + ss_c] != ss_current_state )
    1652 +                       {
    1653 +                       ss_current_state = (int) ss_def[ss_current_state];
    1654 +                       if ( ss_current_state >= 47 )
    1655 +                               ss_c = ss_meta[(unsigned int) ss_c];
    1656 +                       }
    1657 +               ss_current_state = ss_nxt[ss_base[ss_current_state] + (unsigned int) ss_c];
    1658 +               }
    1659 +
    1660 +       return ss_current_state;
    1661 +       }
    1662 +
    1663 +
    1664 +/* ss_try_NUL_trans - try to make a transition on the NUL character
    1665 + *
    1666 + * synopsis
    1667 + *     next_state = ss_try_NUL_trans( current_state );
    1668 + */
    1669 +
    1670 +#ifdef YY_USE_PROTOS
    1671 +static ss_state_type ss_try_NUL_trans( ss_state_type ss_current_state )
    1672 +#else
    1673 +static ss_state_type ss_try_NUL_trans( ss_current_state )
    1674 +ss_state_type ss_current_state;
    1675 +#endif
    1676 +       {
    1677 +       register int ss_is_jam;
    1678 +       register char *ss_cp = ss_c_buf_p;
    1679 +
    1680 +       register YY_CHAR ss_c = 1;
    1681 +       if ( ss_accept[ss_current_state] )
    1682 +               {
    1683 +               ss_last_accepting_state = ss_current_state;
    1684 +               ss_last_accepting_cpos = ss_cp;
    1685 +               }
    1686 +       while ( ss_chk[ss_base[ss_current_state] + ss_c] != ss_current_state )
    1687 +               {
    1688 +               ss_current_state = (int) ss_def[ss_current_state];
    1689 +               if ( ss_current_state >= 47 )
    1690 +                       ss_c = ss_meta[(unsigned int) ss_c];
    1691 +               }
    1692 +       ss_current_state = ss_nxt[ss_base[ss_current_state] + (unsigned int) ss_c];
    1693 +       ss_is_jam = (ss_current_state == 46);
    1694 +
    1695 +       return ss_is_jam ? 0 : ss_current_state;
    1696 +       }
    1697 +
    1698 +
    1699 +#ifndef YY_NO_UNPUT
    1700 +#ifdef YY_USE_PROTOS
    1701 +static void ssunput( int c, register char *ss_bp )
    1702 +#else
    1703 +static void ssunput( c, ss_bp )
    1704 +int c;
    1705 +register char *ss_bp;
    1706 +#endif
    1707 +       {
    1708 +       register char *ss_cp = ss_c_buf_p;
    1709 +
    1710 +       /* undo effects of setting up sstext */
    1711 +       *ss_cp = ss_hold_char;
    1712 +
    1713 +       if ( ss_cp < ss_current_buffer->ss_ch_buf + 2 )
    1714 +               { /* need to shift things up to make room */
    1715 +               /* +2 for EOB chars. */
    1716 +               register int number_to_move = ss_n_chars + 2;
    1717 +               register char *dest = &ss_current_buffer->ss_ch_buf[
    1718 +                                       ss_current_buffer->ss_buf_size + 2];
    1719 +               register char *source =
    1720 +                               &ss_current_buffer->ss_ch_buf[number_to_move];
    1721 +
    1722 +               while ( source > ss_current_buffer->ss_ch_buf )
    1723 +                       *--dest = *--source;
    1724 +
    1725 +               ss_cp += (int) (dest - source);
    1726 +               ss_bp += (int) (dest - source);
    1727 +               ss_current_buffer->ss_n_chars =
    1728 +                       ss_n_chars = ss_current_buffer->ss_buf_size;
    1729 +
    1730 +               if ( ss_cp < ss_current_buffer->ss_ch_buf + 2 )
    1731 +                       YY_FATAL_ERROR( "flex scanner push-back overflow" );
    1732 +               }
    1733 +
    1734 +       *--ss_cp = (char) c;
    1735 +
    1736 +
    1737 +       sstext_ptr = ss_bp;
    1738 +       ss_hold_char = *ss_cp;
    1739 +       ss_c_buf_p = ss_cp;
    1740 +       }
    1741 +#endif /* ifndef YY_NO_UNPUT */
    1742 +
    1743 +
    1744 +#ifdef __cplusplus
    1745 +static int ssinput()
    1746 +#else
    1747 +static int input()
    1748 +#endif
    1749 +       {
    1750 +       int c;
    1751 +
    1752 +       *ss_c_buf_p = ss_hold_char;
    1753 +
    1754 +       if ( *ss_c_buf_p == YY_END_OF_BUFFER_CHAR )
    1755 +               {
    1756 +               /* ss_c_buf_p now points to the character we want to return.
    1757 +                * If this occurs *before* the EOB characters, then it's a
    1758 +                * valid NUL; if not, then we've hit the end of the buffer.
    1759 +                */
    1760 +               if ( ss_c_buf_p < &ss_current_buffer->ss_ch_buf[ss_n_chars] )
    1761 +                       /* This was really a NUL. */
    1762 +                       *ss_c_buf_p = '\0';
    1763 +
    1764 +               else
    1765 +                       { /* need more input */
    1766 +                       int offset = ss_c_buf_p - sstext_ptr;
    1767 +                       ++ss_c_buf_p;
    1768 +
    1769 +                       switch ( ss_get_next_buffer() )
    1770 +                               {
    1771 +                               case EOB_ACT_LAST_MATCH:
    1772 +                                       /* This happens because ss_g_n_b()
    1773 +                                        * sees that we've accumulated a
    1774 +                                        * token and flags that we need to
    1775 +                                        * try matching the token before
    1776 +                                        * proceeding.  But for input(),
    1777 +                                        * there's no matching to consider.
    1778 +                                        * So convert the EOB_ACT_LAST_MATCH
    1779 +                                        * to EOB_ACT_END_OF_FILE.
    1780 +                                        */
    1781 +
    1782 +                                       /* Reset buffer status. */
    1783 +                                       ssrestart( ssin );
    1784 +
    1785 +                                       /* fall through */
    1786 +
    1787 +                               case EOB_ACT_END_OF_FILE:
    1788 +                                       {
    1789 +                                       if ( sswrap() )
    1790 +                                               return EOF;
    1791 +
    1792 +                                       if ( ! ss_did_buffer_switch_on_eof )
    1793 +                                               YY_NEW_FILE;
    1794 +#ifdef __cplusplus
    1795 +                                       return ssinput();
    1796 +#else
    1797 +                                       return input();
    1798 +#endif
    1799 +                                       }
    1800 +
    1801 +                               case EOB_ACT_CONTINUE_SCAN:
    1802 +                                       ss_c_buf_p = sstext_ptr + offset;
    1803 +                                       break;
    1804 +                               }
    1805 +                       }
    1806 +               }
    1807 +
    1808 +       c = *(unsigned char *) ss_c_buf_p;      /* cast for 8-bit char's */
    1809 +       *ss_c_buf_p = '\0';     /* preserve sstext */
    1810 +       ss_hold_char = *++ss_c_buf_p;
    1811 +
    1812 +
    1813 +       return c;
    1814 +       }
    1815 +
    1816 +
    1817 +#ifdef YY_USE_PROTOS
    1818 +void ssrestart( FILE *input_file )
    1819 +#else
    1820 +void ssrestart( input_file )
    1821 +FILE *input_file;
    1822 +#endif
    1823 +       {
    1824 +       if ( ! ss_current_buffer )
    1825 +               ss_current_buffer = ss_create_buffer( ssin, YY_BUF_SIZE );
    1826 +
    1827 +       ss_init_buffer( ss_current_buffer, input_file );
    1828 +       ss_load_buffer_state();
    1829 +       }
    1830 +
    1831 +
    1832 +#ifdef YY_USE_PROTOS
    1833 +void ss_switch_to_buffer( YY_BUFFER_STATE new_buffer )
    1834 +#else
    1835 +void ss_switch_to_buffer( new_buffer )
    1836 +YY_BUFFER_STATE new_buffer;
    1837 +#endif
    1838 +       {
    1839 +       if ( ss_current_buffer == new_buffer )
    1840 +               return;
    1841 +
    1842 +       if ( ss_current_buffer )
    1843 +               {
    1844 +               /* Flush out information for old buffer. */
    1845 +               *ss_c_buf_p = ss_hold_char;
    1846 +               ss_current_buffer->ss_buf_pos = ss_c_buf_p;
    1847 +               ss_current_buffer->ss_n_chars = ss_n_chars;
    1848 +               }
    1849 +
    1850 +       ss_current_buffer = new_buffer;
    1851 +       ss_load_buffer_state();
    1852 +
    1853 +       /* We don't actually know whether we did this switch during
    1854 +        * EOF (sswrap()) processing, but the only time this flag
    1855 +        * is looked at is after sswrap() is called, so it's safe
    1856 +        * to go ahead and always set it.
    1857 +        */
    1858 +       ss_did_buffer_switch_on_eof = 1;
    1859 +       }
    1860 +
    1861 +
    1862 +#ifdef YY_USE_PROTOS
    1863 +void ss_load_buffer_state( void )
    1864 +#else
    1865 +void ss_load_buffer_state()
    1866 +#endif
    1867 +       {
    1868 +       ss_n_chars = ss_current_buffer->ss_n_chars;
    1869 +       sstext_ptr = ss_c_buf_p = ss_current_buffer->ss_buf_pos;
    1870 +       ssin = ss_current_buffer->ss_input_file;
    1871 +       ss_hold_char = *ss_c_buf_p;
    1872 +       }
    1873 +
    1874 +
    1875 +#ifdef YY_USE_PROTOS
    1876 +YY_BUFFER_STATE ss_create_buffer( FILE *file, int size )
    1877 +#else
    1878 +YY_BUFFER_STATE ss_create_buffer( file, size )
    1879 +FILE *file;
    1880 +int size;
    1881 +#endif
    1882 +       {
    1883 +       YY_BUFFER_STATE b;
    1884 +
    1885 +       b = (YY_BUFFER_STATE) ss_flex_alloc( sizeof( struct ss_buffer_state ) );
    1886 +       if ( ! b )
    1887 +               YY_FATAL_ERROR( "out of dynamic memory in ss_create_buffer()" );
    1888 +
    1889 +       b->ss_buf_size = size;
    1890 +
    1891 +       /* ss_ch_buf has to be 2 characters longer than the size given because
    1892 +        * we need to put in 2 end-of-buffer characters.
    1893 +        */
    1894 +       b->ss_ch_buf = (char *) ss_flex_alloc( b->ss_buf_size + 2 );
    1895 +       if ( ! b->ss_ch_buf )
    1896 +               YY_FATAL_ERROR( "out of dynamic memory in ss_create_buffer()" );
    1897 +
    1898 +       b->ss_is_our_buffer = 1;
    1899 +
    1900 +       ss_init_buffer( b, file );
    1901 +
    1902 +       return b;
    1903 +       }
    1904 +
    1905 +
    1906 +#ifdef YY_USE_PROTOS
    1907 +void ss_delete_buffer( YY_BUFFER_STATE b )
    1908 +#else
    1909 +void ss_delete_buffer( b )
    1910 +YY_BUFFER_STATE b;
    1911 +#endif
    1912 +       {
    1913 +       if ( ! b )
    1914 +               return;
    1915 +
    1916 +       if ( b == ss_current_buffer )
    1917 +               ss_current_buffer = (YY_BUFFER_STATE) 0;
    1918 +
    1919 +       if ( b->ss_is_our_buffer )
    1920 +               ss_flex_free( (void *) b->ss_ch_buf );
    1921 +
    1922 +       ss_flex_free( (void *) b );
    1923 +       }
    1924 +
    1925 +
    1926 +#ifndef YY_ALWAYS_INTERACTIVE
    1927 +#ifndef YY_NEVER_INTERACTIVE
    1928 +extern int isatty YY_PROTO(( int ));
    1929 +#endif
    1930 +#endif
    1931 +
    1932 +#ifdef YY_USE_PROTOS
    1933 +void ss_init_buffer( YY_BUFFER_STATE b, FILE *file )
    1934 +#else
    1935 +void ss_init_buffer( b, file )
    1936 +YY_BUFFER_STATE b;
    1937 +FILE *file;
    1938 +#endif
    1939 +
    1940 +
    1941 +       {
    1942 +       ss_flush_buffer( b );
    1943 +
    1944 +       b->ss_input_file = file;
    1945 +       b->ss_fill_buffer = 1;
    1946 +
    1947 +#if YY_ALWAYS_INTERACTIVE
    1948 +       b->ss_is_interactive = 1;
    1949 +#else
    1950 +#if YY_NEVER_INTERACTIVE
    1951 +       b->ss_is_interactive = 0;
    1952 +#else
    1953 +       b->ss_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
    1954 +#endif
    1955 +#endif
    1956 +       }
    1957 +
    1958 +
    1959 +#ifdef YY_USE_PROTOS
    1960 +void ss_flush_buffer( YY_BUFFER_STATE b )
    1961 +#else
    1962 +void ss_flush_buffer( b )
    1963 +YY_BUFFER_STATE b;
    1964 +#endif
    1965 +
    1966 +       {
    1967 +       if ( ! b )
    1968 +               return;
    1969 +
    1970 +       b->ss_n_chars = 0;
    1971 +
    1972 +       /* We always need two end-of-buffer characters.  The first causes
    1973 +        * a transition to the end-of-buffer state.  The second causes
    1974 +        * a jam in that state.
    1975 +        */
    1976 +       b->ss_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
    1977 +       b->ss_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
    1978 +
    1979 +       b->ss_buf_pos = &b->ss_ch_buf[0];
    1980 +
    1981 +       b->ss_at_bol = 1;
    1982 +       b->ss_buffer_status = YY_BUFFER_NEW;
    1983 +
    1984 +       if ( b == ss_current_buffer )
    1985 +               ss_load_buffer_state();
    1986 +       }
    1987 +
    1988 +
    1989 +#ifndef YY_NO_SCAN_BUFFER
    1990 +#ifdef YY_USE_PROTOS
    1991 +YY_BUFFER_STATE ss_scan_buffer( char *base, ss_size_t size )
    1992 +#else
    1993 +YY_BUFFER_STATE ss_scan_buffer( base, size )
    1994 +char *base;
    1995 +ss_size_t size;
    1996 +#endif
    1997 +       {
    1998 +       YY_BUFFER_STATE b;
    1999 +
    2000 +       if ( size < 2 ||
    2001 +            base[size-2] != YY_END_OF_BUFFER_CHAR ||
    2002 +            base[size-1] != YY_END_OF_BUFFER_CHAR )
    2003 +               /* They forgot to leave room for the EOB's. */
    2004 +               return 0;
    2005 +
    2006 +       b = (YY_BUFFER_STATE) ss_flex_alloc( sizeof( struct ss_buffer_state ) );
    2007 +       if ( ! b )
    2008 +               YY_FATAL_ERROR( "out of dynamic memory in ss_scan_buffer()" );
    2009 +
    2010 +       b->ss_buf_size = size - 2;      /* "- 2" to take care of EOB's */
    2011 +       b->ss_buf_pos = b->ss_ch_buf = base;
    2012 +       b->ss_is_our_buffer = 0;
    2013 +       b->ss_input_file = 0;
    2014 +       b->ss_n_chars = b->ss_buf_size;
    2015 +       b->ss_is_interactive = 0;
    2016 +       b->ss_at_bol = 1;
    2017 +       b->ss_fill_buffer = 0;
    2018 +       b->ss_buffer_status = YY_BUFFER_NEW;
    2019 +
    2020 +       ss_switch_to_buffer( b );
    2021 +
    2022 +       return b;
    2023 +       }
    2024 +#endif
    2025 +
    2026 +
    2027 +#ifndef YY_NO_SCAN_STRING
    2028 +#ifdef YY_USE_PROTOS
    2029 +YY_BUFFER_STATE ss_scan_string( ssconst char *ss_str )
    2030 +#else
    2031 +YY_BUFFER_STATE ss_scan_string( ss_str )
    2032 +ssconst char *ss_str;
    2033 +#endif
    2034 +       {
    2035 +       int len;
    2036 +       for ( len = 0; ss_str[len]; ++len )
    2037 +               ;
    2038 +
    2039 +       return ss_scan_bytes( ss_str, len );
    2040 +       }
    2041 +#endif
    2042 +
    2043 +
    2044 +#ifndef YY_NO_SCAN_BYTES
    2045 +#ifdef YY_USE_PROTOS
    2046 +YY_BUFFER_STATE ss_scan_bytes( ssconst char *bytes, int len )
    2047 +#else
    2048 +YY_BUFFER_STATE ss_scan_bytes( bytes, len )
    2049 +ssconst char *bytes;
    2050 +int len;
    2051 +#endif
    2052 +       {
    2053 +       YY_BUFFER_STATE b;
    2054 +       char *buf;
    2055 +       ss_size_t n;
    2056 +       int i;
    2057 +
    2058 +       /* Get memory for full buffer, including space for trailing EOB's. */
    2059 +       n = len + 2;
    2060 +       buf = (char *) ss_flex_alloc( n );
    2061 +       if ( ! buf )
    2062 +               YY_FATAL_ERROR( "out of dynamic memory in ss_scan_bytes()" );
    2063 +
    2064 +       for ( i = 0; i < len; ++i )
    2065 +               buf[i] = bytes[i];
    2066 +
    2067 +       buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
    2068 +
    2069 +       b = ss_scan_buffer( buf, n );
    2070 +       if ( ! b )
    2071 +               YY_FATAL_ERROR( "bad buffer in ss_scan_bytes()" );
    2072 +
    2073 +       /* It's okay to grow etc. this buffer, and we should throw it
    2074 +        * away when we're done.
    2075 +        */
    2076 +       b->ss_is_our_buffer = 1;
    2077 +
    2078 +       return b;
    2079 +       }
    2080 +#endif
    2081 +
    2082 +
    2083 +#ifndef YY_NO_PUSH_STATE
    2084 +#ifdef YY_USE_PROTOS
    2085 +static void ss_push_state( int new_state )
    2086 +#else
    2087 +static void ss_push_state( new_state )
    2088 +int new_state;
    2089 +#endif
    2090 +       {
    2091 +       if ( ss_start_stack_ptr >= ss_start_stack_depth )
    2092 +               {
    2093 +               ss_size_t new_size;
    2094 +
    2095 +               ss_start_stack_depth += YY_START_STACK_INCR;
    2096 +               new_size = ss_start_stack_depth * sizeof( int );
    2097 +
    2098 +               if ( ! ss_start_stack )
    2099 +                       ss_start_stack = (int *) ss_flex_alloc( new_size );
    2100 +
    2101 +               else
    2102 +                       ss_start_stack = (int *) ss_flex_realloc(
    2103 +                                       (void *) ss_start_stack, new_size );
    2104 +
    2105 +               if ( ! ss_start_stack )
    2106 +                       YY_FATAL_ERROR(
    2107 +                       "out of memory expanding start-condition stack" );
    2108 +               }
    2109 +
    2110 +       ss_start_stack[ss_start_stack_ptr++] = YY_START;
    2111 +
    2112 +       BEGIN(new_state);
    2113 +       }
    2114 +#endif
    2115 +
    2116 +
    2117 +#ifndef YY_NO_POP_STATE
    2118 +static void ss_pop_state()
    2119 +       {
    2120 +       if ( --ss_start_stack_ptr < 0 )
    2121 +               YY_FATAL_ERROR( "start-condition stack underflow" );
    2122 +
    2123 +       BEGIN(ss_start_stack[ss_start_stack_ptr]);
    2124 +       }
    2125 +#endif
    2126 +
    2127 +
    2128 +#ifndef YY_NO_TOP_STATE
    2129 +static int ss_top_state()
    2130 +       {
    2131 +       return ss_start_stack[ss_start_stack_ptr - 1];
    2132 +       }
    2133 +#endif
    2134 +
    2135 +#ifndef YY_EXIT_FAILURE
    2136 +#define YY_EXIT_FAILURE 2
    2137 +#endif
    2138 +
    2139 +#ifdef YY_USE_PROTOS
    2140 +static void ss_fatal_error( ssconst char msg[] )
    2141 +#else
    2142 +static void ss_fatal_error( msg )
    2143 +char msg[];
    2144 +#endif
    2145 +       {
    2146 +       (void) fprintf( stderr, "%s\n", msg );
    2147 +       exit( YY_EXIT_FAILURE );
    2148 +       }
    2149 +
    2150 +
    2151 +
    2152 +/* Redefine ssless() so it works in section 3 code. */
    2153 +
    2154 +#undef ssless
    2155 +#define ssless(n) \
    2156 +       do \
    2157 +               { \
    2158 +               /* Undo effects of setting up sstext. */ \
    2159 +               sstext[ssleng] = ss_hold_char; \
    2160 +               ss_c_buf_p = sstext + n; \
    2161 +               ss_hold_char = *ss_c_buf_p; \
    2162 +               *ss_c_buf_p = '\0'; \
    2163 +               ssleng = n; \
    2164 +               } \
    2165 +       while ( 0 )
    2166 +
    2167 +
    2168 +/* Internal utility routines. */
    2169 +
    2170 +#ifndef sstext_ptr
    2171 +#ifdef YY_USE_PROTOS
    2172 +static void ss_flex_strncpy( char *s1, ssconst char *s2, int n )
    2173 +#else
    2174 +static void ss_flex_strncpy( s1, s2, n )
    2175 +char *s1;
    2176 +ssconst char *s2;
    2177 +int n;
    2178 +#endif
    2179 +       {
    2180 +       register int i;
    2181 +       for ( i = 0; i < n; ++i )
    2182 +               s1[i] = s2[i];
    2183 +       }
    2184 +#endif
    2185 +
    2186 +#ifdef YY_NEED_STRLEN
    2187 +#ifdef YY_USE_PROTOS
    2188 +static int ss_flex_strlen( ssconst char *s )
    2189 +#else
    2190 +static int ss_flex_strlen( s )
    2191 +ssconst char *s;
    2192 +#endif
    2193 +       {
    2194 +       register int n;
    2195 +       for ( n = 0; s[n]; ++n )
    2196 +               ;
    2197 +
    2198 +       return n;
    2199 +       }
    2200 +#endif
    2201 +
    2202 +
    2203 +#ifdef YY_USE_PROTOS
    2204 +static void *ss_flex_alloc( ss_size_t size )
    2205 +#else
    2206 +static void *ss_flex_alloc( size )
    2207 +ss_size_t size;
    2208 +#endif
    2209 +       {
    2210 +       return (void *) malloc( size );
    2211 +       }
    2212 +
    2213 +#ifdef YY_USE_PROTOS
    2214 +static void *ss_flex_realloc( void *ptr, ss_size_t size )
    2215 +#else
    2216 +static void *ss_flex_realloc( ptr, size )
    2217 +void *ptr;
    2218 +ss_size_t size;
    2219 +#endif
    2220 +       {
    2221 +       /* The cast to (char *) in the following accommodates both
    2222 +        * implementations that use char* generic pointers, and those
    2223 +        * that use void* generic pointers.  It works with the latter
    2224 +        * because both ANSI C and C++ allow castless assignment from
    2225 +        * any pointer type to void*, and deal with argument conversions
    2226 +        * as though doing an assignment.
    2227 +        */
    2228 +       return (void *) realloc( (char *) ptr, size );
    2229 +       }
    2230 +
    2231 +#ifdef YY_USE_PROTOS
    2232 +static void ss_flex_free( void *ptr )
    2233 +#else
    2234 +static void ss_flex_free( ptr )
    2235 +void *ptr;
    2236 +#endif
    2237 +       {
    2238 +       free( ptr );
    2239 +       }
    2240 +
    2241 +#if YY_MAIN
    2242 +int main()
    2243 +       {
    2244 +       sslex();
    2245 +       return 0;
    2246 +       }
    2247 +#endif
    2248 +#line 107 "icalsslexer.l"
    2249 +
    2250 +
    2251 +int sswrap()
    2252 +{
    2253 +     return 1;
    2254 +}
    2255 +
    2256572--- libkcal/Makefile.am 29 Oct 2002 18:09:14 -0000      1.1.1.4
    2257573+++ libkcal/Makefile.am 29 Nov 2002 19:01:22 -0000      1.2
  • trunk/dports/x11/kdeutils3/files/patch-kdeutils3-3.1.darwin

    r1900 r1914  
    88+DO_NOT_COMPILE="$DO_NOT_COMPILE klaptopdaemon"
    99--- ark/Makefile.am     18 Jan 2003 02:10:59 -0000      1.1.1.5
    10 +++ ark/Makefile.am     20 Jan 2003 01:09:23 -0000
     10+++ ark/Makefile.am     28 Jan 2003 15:38:22 -0000
    1111@@ -5,23 +5,31 @@
    1212 
Note: See TracChangeset for help on using the changeset viewer.