Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit bae6579e authored by Andy McFadden's avatar Andy McFadden
Browse files

Remove native EventRecurrence parser 

Switch over to the new parser.

Bug 4575374

Change-Id: If78d8042fb266182900398f7fc464a048c779966
parent 2b4b4f44

include/pim/EventRecurrence.h

deleted100644 → 0
+0 −82
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2006 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



//

#ifndef _PIM_EVENT_RECURRENCE_H

#define _PIM_EVENT_RECURRENCE_H



#include <utils/String16.h>



namespace android {



struct EventRecurrence

{

public:

                EventRecurrence();

                ~EventRecurrence();

    

    status_t    parse(const String16&);





    enum freq_t {

        SECONDLY = 1,

        MINUTELY = 2,

        HOURLY = 3,

        DAILY = 4,

        WEEKLY = 5,

        MONTHLY = 6,

        YEARLY = 7

    };



    enum {

        SU = 0x00010000,

        MO = 0x00020000,

        TU = 0x00040000,

        WE = 0x00080000,

        TH = 0x00100000,

        FR = 0x00200000,

        SA = 0x00400000

    };

    

    freq_t    freq;

    String16  until;

    int       count;

    int       interval;

    int*      bysecond;

    int       bysecondCount;

    int*      byminute;

    int       byminuteCount;

    int*      byhour;

    int       byhourCount;

    int*      byday;

    int*      bydayNum;

    int       bydayCount;   

    int*      bymonthday;

    int       bymonthdayCount;

    int*      byyearday;

    int       byyeardayCount;

    int*      byweekno;

    int       byweeknoCount;

    int*      bymonth;

    int       bymonthCount;

    int*      bysetpos;

    int       bysetposCount;

    int       wkst;

};



}; // namespace android



#endif // _PIM_EVENT_RECURRENCE_H

libs/ui/Android.mk

+0 −1
Original line number Diff line number Diff line
@@ -43,7 +43,6 @@ include $(CLEAR_VARS) 
LOCAL_SRC_FILES:= \

	$(commonSources) \

	EGLUtils.cpp \

	EventRecurrence.cpp \

	FramebufferNativeWindow.cpp \

	GraphicBuffer.cpp \

	GraphicBufferAllocator.cpp \

libs/ui/EventRecurrence.cpp

deleted100644 → 0
+0 −484
Original line number Diff line number Diff line 
/*

 *  Copyright 2006 The Android Open Source Project

 */



#include <pim/EventRecurrence.h>

#include <utils/String8.h>

#include <stdio.h>

#include <limits.h>



namespace android {



#define FAIL_HERE() do { \

            printf("Parsing failed at line %d\n", __LINE__); \

            return UNKNOWN_ERROR; \

        } while(0)



EventRecurrence::EventRecurrence()

    :freq((freq_t)0),

     until(),

     count(0),

     interval(0),

     bysecond(0),

     bysecondCount(0),

     byminute(0),

     byminuteCount(0),

     byhour(0),

     byhourCount(0),

     byday(0),

     bydayNum(0),

     bydayCount(0),

     bymonthday(0),

     bymonthdayCount(0),

     byyearday(0),

     byyeardayCount(0),

     byweekno(0),

     byweeknoCount(0),

     bymonth(0),

     bymonthCount(0),

     bysetpos(0),

     bysetposCount(0),

     wkst(0)

{

}



EventRecurrence::~EventRecurrence()

{

    delete[] bysecond;

    delete[] byminute;

    delete[] byhour;

    delete[] byday;

    delete[] bydayNum;

    delete[] byyearday;

    delete[] bymonthday;

    delete[] byweekno;

    delete[] bymonth;

    delete[] bysetpos;

}



enum LHS {

    NONE_LHS = 0,

    FREQ,

    UNTIL,

    COUNT,

    INTERVAL,

    BYSECOND,

    BYMINUTE,

    BYHOUR,

    BYDAY,

    BYMONTHDAY,

    BYYEARDAY,

    BYWEEKNO,

    BYMONTH,

    BYSETPOS,

    WKST

};



struct LHSProc

{

    const char16_t* text;

    size_t textSize;

    uint32_t value;

};



const char16_t FREQ_text[] = { 'F', 'R', 'E', 'Q' };

const char16_t UNTIL_text[] = { 'U', 'N', 'T', 'I', 'L' };

const char16_t COUNT_text[] = { 'C', 'O', 'U', 'N', 'T' };

const char16_t INTERVAL_text[] = { 'I', 'N', 'T', 'E', 'R', 'V', 'A', 'L'};

const char16_t BYSECOND_text[] = { 'B', 'Y', 'S', 'E', 'C', 'O', 'N', 'D' };

const char16_t BYMINUTE_text[] = { 'B', 'Y', 'M', 'I', 'N', 'U', 'T', 'E' };

const char16_t BYHOUR_text[] = { 'B', 'Y', 'H', 'O', 'U', 'R' };

const char16_t BYDAY_text[] = { 'B', 'Y', 'D', 'A', 'Y' };

const char16_t BYMONTHDAY_text[] = { 'B','Y','M','O','N','T','H','D','A','Y' };

const char16_t BYYEARDAY_text[] = { 'B','Y','Y','E','A','R','D','A','Y' };

const char16_t BYWEEKNO_text[] = { 'B', 'Y', 'W', 'E', 'E', 'K', 'N', 'O' };

const char16_t BYMONTH_text[] = { 'B', 'Y', 'M', 'O', 'N', 'T', 'H' };

const char16_t BYSETPOS_text[] = { 'B', 'Y', 'S', 'E', 'T', 'P', 'O', 'S' };

const char16_t WKST_text[] = { 'W', 'K', 'S', 'T' };



#define SIZ(x) (sizeof(x)/sizeof(x[0]))



const LHSProc LHSPROC[] = {

    { FREQ_text, SIZ(FREQ_text), FREQ },

    { UNTIL_text, SIZ(UNTIL_text), UNTIL },

    { COUNT_text, SIZ(COUNT_text), COUNT },

    { INTERVAL_text, SIZ(INTERVAL_text), INTERVAL },

    { BYSECOND_text, SIZ(BYSECOND_text), BYSECOND },

    { BYMINUTE_text, SIZ(BYMINUTE_text), BYMINUTE },

    { BYHOUR_text, SIZ(BYHOUR_text), BYHOUR },

    { BYDAY_text, SIZ(BYDAY_text), BYDAY },

    { BYMONTHDAY_text, SIZ(BYMONTHDAY_text), BYMONTHDAY },

    { BYYEARDAY_text, SIZ(BYYEARDAY_text), BYYEARDAY },

    { BYWEEKNO_text, SIZ(BYWEEKNO_text), BYWEEKNO },

    { BYMONTH_text, SIZ(BYMONTH_text), BYMONTH },

    { BYSETPOS_text, SIZ(BYSETPOS_text), BYSETPOS },

    { WKST_text, SIZ(WKST_text), WKST },

    { NULL, 0, NONE_LHS },

};



const char16_t SECONDLY_text[] = { 'S','E','C','O','N','D','L','Y' };

const char16_t MINUTELY_text[] = { 'M','I','N','U','T','E','L','Y' };

const char16_t HOURLY_text[] = { 'H','O','U','R','L','Y' };

const char16_t DAILY_text[] = { 'D','A','I','L','Y' };

const char16_t WEEKLY_text[] = { 'W','E','E','K','L','Y' };

const char16_t MONTHLY_text[] = { 'M','O','N','T','H','L','Y' };

const char16_t YEARLY_text[] = { 'Y','E','A','R','L','Y' };



typedef LHSProc FreqProc;



const FreqProc FREQPROC[] = {

    { SECONDLY_text, SIZ(SECONDLY_text), EventRecurrence::SECONDLY },

    { MINUTELY_text, SIZ(MINUTELY_text), EventRecurrence::MINUTELY },

    { HOURLY_text, SIZ(HOURLY_text), EventRecurrence::HOURLY },

    { DAILY_text, SIZ(DAILY_text), EventRecurrence::DAILY },

    { WEEKLY_text, SIZ(WEEKLY_text), EventRecurrence::WEEKLY },

    { MONTHLY_text, SIZ(MONTHLY_text), EventRecurrence::MONTHLY },

    { YEARLY_text, SIZ(YEARLY_text), EventRecurrence::YEARLY },

    { NULL, 0, NONE_LHS },

};



const char16_t SU_text[] = { 'S','U' };

const char16_t MO_text[] = { 'M','O' };

const char16_t TU_text[] = { 'T','U' };

const char16_t WE_text[] = { 'W','E' };

const char16_t TH_text[] = { 'T','H' };

const char16_t FR_text[] = { 'F','R' };

const char16_t SA_text[] = { 'S','A' };



const FreqProc WEEKDAYPROC[] = {

    { SU_text, SIZ(SU_text), EventRecurrence::SU },

    { MO_text, SIZ(MO_text), EventRecurrence::MO },

    { TU_text, SIZ(TU_text), EventRecurrence::TU },

    { WE_text, SIZ(WE_text), EventRecurrence::WE },

    { TH_text, SIZ(TH_text), EventRecurrence::TH },

    { FR_text, SIZ(FR_text), EventRecurrence::FR },

    { SA_text, SIZ(SA_text), EventRecurrence::SA },

    { NULL, 0, NONE_LHS },

};



// returns the index into LHSPROC for the match or -1 if not found

inline static int

match_proc(const LHSProc* p, const char16_t* str, size_t len)

{

    int i = 0;

    while (p->text != NULL) {

        if (p->textSize == len) {

            if (0 == memcmp(p->text, str, len*sizeof(char16_t))) {

                return i;

            }

        }

        p++;

        i++;

    }

    return -1;

}



// rangeMin and rangeMax are inclusive

static status_t

parse_int(const char16_t* str, size_t len, int* out,

            int rangeMin, int rangeMax, bool zeroOK)

{

    char16_t c;

    size_t i=0;



    if (len == 0) {

        FAIL_HERE();

    }

    bool negative = false;

    c = str[0];

    if (c == '-' ) {

        negative = true;

        i++;

    }

    else if (c == '+') {

        i++;

    }

    int n = 0;

    for (; i<len; i++) {

        c = str[i];

        if (c < '0' || c > '9') {

            FAIL_HERE();

        }

        int prev = n;

        n *= 10;

        // the spec doesn't address how big these numbers can be,

        // so we're not going to worry about not being able to represent

        // INT_MIN, and if we're going to wrap, we'll just clamp to

        // INT_MAX instead

        if (n < prev) {

            n = INT_MAX;

        } else {

            n += c - '0';

        }

    }

    if (negative) {

        n = -n;

    }

    if (n < rangeMin || n > rangeMax) {

        FAIL_HERE();

    }

    if (!zeroOK && n == 0) {

        FAIL_HERE();

    }

    *out = n;

    return NO_ERROR;

}



static status_t

parse_int_list(const char16_t* str, size_t len, int* countOut, int** listOut,

          int rangeMin, int rangeMax, bool zeroOK,

          status_t (*func)(const char16_t*,size_t,int*,int,int,bool)=parse_int)

{

    status_t err;



    if (len == 0) {

        *countOut = 0;

        *listOut = NULL;

        return NO_ERROR;

    }



    // make one pass through looking for commas so we know how big to make our

    // out array.

    int count = 1;

    for (size_t i=0; i<len; i++) {

        if (str[i] == ',') {

            count++;

        }

    }



    int* list = new int[count];

    const char16_t* p = str;

    int commaIndex = 0;

    size_t i;



    for (i=0; i<len; i++) {

        if (str[i] == ',') {

            err = func(p, (str+i-p), list+commaIndex, rangeMin,

                    rangeMax, zeroOK);

            if (err != NO_ERROR) {

                goto bail;

            }

            commaIndex++;

            p = str+i+1;

        }

    }



    err = func(p, (str+i-p), list+commaIndex, rangeMin, rangeMax, zeroOK);

    if (err != NO_ERROR) {

        goto bail;

    }

    commaIndex++;



    *countOut = count;

    *listOut = list;



    return NO_ERROR;



bail:

    delete[] list;

    FAIL_HERE();

}



// the numbers here are small, so we pack them both into one value, and then

// split it out later.  it lets us reuse all the comma separated list code.

static status_t

parse_byday(const char16_t* s, size_t len, int* out,

            int rangeMin, int rangeMax, bool zeroOK)

{

    status_t err;

    int n = 0;

    const char16_t* p = s;

    size_t plen = len;



    if (len > 0) {

        char16_t c = s[0];

        if (c == '-' || c == '+' || (c >= '0' && c <= '9')) {

            if (len > 1) {

                size_t nlen = 0;

                c = s[nlen];

                while (nlen < len

                        && (c == '-' || c == '+' || (c >= '0' && c <= '9'))) {

                    c = s[nlen];

                    nlen++;

                }

                if (nlen > 0) {

                    nlen--;

                    err = parse_int(s, nlen, &n, rangeMin, rangeMax, zeroOK);

                    if (err != NO_ERROR) {

                        FAIL_HERE();

                    }

                    p += nlen;

                    plen -= nlen;

                }

            }

        }



        int index = match_proc(WEEKDAYPROC, p, plen);

        if (index >= 0) {

            *out = (0xffff0000 & WEEKDAYPROC[index].value)

                    | (0x0000ffff & n);

            return NO_ERROR;

        }

    }

    return UNKNOWN_ERROR;

}



static void

postprocess_byday(int count, int* byday, int** bydayNum)

{

    int* bdn = new int[count];

    *bydayNum = bdn;

    for (int i=0; i<count; i++) {

        uint32_t v = byday[i];

        int16_t num = v & 0x0000ffff;

        byday[i] = v & 0xffff0000;  

        // will sign extend:

        bdn[i] = num;

    }

}



#define PARSE_INT_LIST_CHECKED(name, rangeMin, rangeMax, zeroOK) \

    if (name##Count != 0 || NO_ERROR != parse_int_list(s, slen, \

                         &name##Count, &name, rangeMin, rangeMax, zeroOK)) { \

        FAIL_HERE(); \

    }

status_t

EventRecurrence::parse(const String16& str)

{

    char16_t const* work = str.string();

    size_t len = str.size();



    int lhsIndex = NONE_LHS;

    int index;

    

    size_t start = 0;

    for (size_t i=0; i<len; i++) {

        char16_t c = work[i];

        if (c != ';' && i == len-1) {

            c = ';';

            i++;

        }

        if (c == ';' || c == '=') {

            if (i != start) {

                const char16_t* s = work+start;

                const size_t slen = i-start;



                String8 thestring(String16(s, slen));



                switch (c)

                {

                    case '=':

                        if (lhsIndex == NONE_LHS) {

                            lhsIndex = match_proc(LHSPROC, s, slen);

                            if (lhsIndex >= 0) {

                                break;

                            }

                        }

                        FAIL_HERE();

                    case ';':

                    {

                        switch (LHSPROC[lhsIndex].value)

                        {

                            case FREQ:

                                if (this->freq != 0) {

                                    FAIL_HERE();

                                }

                                index = match_proc(FREQPROC, s, slen);

                                if (index >= 0) {

                                    this->freq = (freq_t)FREQPROC[index].value;

                                }

                                break;

                            case UNTIL:

                                // XXX should check that this is a valid time

                                until.setTo(String16(s, slen));

                                break;

                            case COUNT:

                                if (count != 0

                                     || NO_ERROR != parse_int(s, slen,

                                             &count, INT_MIN, INT_MAX, true)) {

                                    FAIL_HERE();

                                }

                                break;

                            case INTERVAL:

                                if (interval != 0

                                     || NO_ERROR != parse_int(s, slen,

                                         &interval, INT_MIN, INT_MAX, false)) {

                                    FAIL_HERE();

                                }

                                break;

                            case BYSECOND:

                                PARSE_INT_LIST_CHECKED(bysecond, 0, 59, true)

                                break;

                            case BYMINUTE:

                                PARSE_INT_LIST_CHECKED(byminute, 0, 59, true)

                                break;

                            case BYHOUR:

                                PARSE_INT_LIST_CHECKED(byhour, 0, 23, true)

                                break;

                            case BYDAY:

                                if (bydayCount != 0 || NO_ERROR != 

                                        parse_int_list(s, slen, &bydayCount,

                                              &byday, -53, 53, false,

                                              parse_byday)) {

                                    FAIL_HERE();

                                }

                                postprocess_byday(bydayCount, byday, &bydayNum);

                                break;

                            case BYMONTHDAY:

                                PARSE_INT_LIST_CHECKED(bymonthday, -31, 31,

                                                        false)

                                break;

                            case BYYEARDAY:

                                PARSE_INT_LIST_CHECKED(byyearday, -366, 366,

                                                        false)

                                break;

                            case BYWEEKNO:

                                PARSE_INT_LIST_CHECKED(byweekno, -53, 53,

                                                        false)

                                break;

                            case BYMONTH:

                                PARSE_INT_LIST_CHECKED(bymonth, 1, 12, false)

                                break;

                            case BYSETPOS:

                                PARSE_INT_LIST_CHECKED(bysetpos,

                                                        INT_MIN, INT_MAX, true)

                                break;

                            case WKST:

                                if (this->wkst != 0) {

                                    FAIL_HERE();

                                }

                                index = match_proc(WEEKDAYPROC, s, slen);

                                if (index >= 0) {

                                    this->wkst = (int)WEEKDAYPROC[index].value;

                                }

                                break;

                            default:

                                FAIL_HERE();

                        }

                        lhsIndex = NONE_LHS;

                        break;

                    }

                }



                start = i+1;

            }

        }

    }



    // enforce that there was a FREQ

    if (freq == 0) {

        FAIL_HERE();

    }



    // default wkst to MO if it wasn't specified

    if (wkst == 0) {

        wkst = MO;

    }



    return NO_ERROR;

}





}; // namespace android