Changeset 34769

Show
Ignore:
Timestamp:
08/06/09 04:22:12 (5 years ago)
Author:
saturday06
Message:

adjfioadfaf

Location:
lang/objective-cplusplus/i3/trunk
Files:
9 modified

Legend:

Unmodified
Added
Removed
  • lang/objective-cplusplus/i3/trunk/am/mil_test.am

    r34474 r34769  
    77src/mil/src/TestMain.cpp \ 
    88src/mil/src/StaticData.cpp \ 
    9 src/mil/src/Test1.cpp \ 
    10 src/mil/src/Test2.cpp \ 
    11 src/mil/src/Test3.cpp \ 
    12 src/mil/src/Test4.cpp \ 
    13 src/mil/src/Test6.cpp \ 
    14 src/mil/src/Test7.cpp \ 
    15 src/mil/src/Test8.cpp \ 
    16 src/mil/src/Test9.cpp \ 
    17 src/mil/src/Test10.cpp 
     9src/mil/src/Test11.cpp 
    1810 
     11# src/mil/src/Test1.cpp \ 
     12# src/mil/src/Test2.cpp \ 
     13# src/mil/src/Test3.cpp \ 
     14# src/mil/src/Test4.cpp \ 
     15# src/mil/src/Test6.cpp \ 
     16# src/mil/src/Test7.cpp \ 
     17# src/mil/src/Test8.cpp \ 
     18# src/mil/src/Test9.cpp \ 
     19# src/mil/src/Test10.cpp 
    1920 
     21# src/mil/src/Test11.cpp 
    2022# src/mil/src/BoostTestDummyLib.cpp 
    21  
    22  
    2323 
    2424mil_test_CXXFLAGS = ${i3_CXXFLAGS} \ 
    2525                    ${WARNING_OPTIONS} \ 
    2626                    -I${top_srcdir}/src/mil/include 
     27                    #-DMIL_PRODUCER_MALLOC 
    2728 
    2829mil_test_LDFLAGS  = ${PTHREAD_LIBS} ${BOOST_LDFLAGS} 
  • lang/objective-cplusplus/i3/trunk/src/gui-windows/InputWindowPlatform.cpp

    r34723 r34769  
    482482    int richedit_style = WS_CHILD | WS_VISIBLE | WS_TABSTOP; 
    483483    int richedit_exstyle = 0; 
     484    richedit_exstyle |= WS_EX_CLIENTEDGE; 
    484485    if (!is_dwm_extend_frame_into_client_area) { 
    485486        //richedit_style |= WS_BORDER; 
    486         richedit_exstyle |= WS_EX_CLIENTEDGE; 
     487        //richedit_exstyle |= WS_EX_CLIENTEDGE; 
    487488    } 
    488489#ifndef _WIN32_WCE 
  • lang/objective-cplusplus/i3/trunk/src/mil/include/mil/Module.h

    r34723 r34769  
    88 * public members should be thread safe 
    99 */ 
    10 template <typename Child> 
    11 class Module : public ModuleCommon<Module<Child>, MIL_DEFAULT_THREAD> { 
    12 public: 
    13     Tls tls; 
    14     MIL_CRTP_CLASS_MEMBERS; 
    15  
    16 private: 
    17     class EventBase : public boost::noncopyable { 
    18     public: 
    19         void (*execute)(void* event, void* target); 
    20         intptr_t owner_id; 
    21         EventBase* next; 
    22     }; 
    23  
    24     class EventList : public boost::noncopyable { 
    25         EventBase* head; 
    26         EventBase* tail; 
    27         Mutex mutex; 
    28     public: 
    29         EventList() { 
    30             head = NULL; 
    31             tail = NULL; 
    32         } 
    33  
    34         void push(EventBase& e) { 
    35             synchronized (mutex) { 
    36                 e.next = NULL; 
    37                 if (head == NULL) { // tail == NULL 
    38                     head = &e; 
    39                     tail = &e; 
    40                     return; 
    41                 } 
    42                 tail->next = &e; 
    43                 tail = &e; 
    44             } 
    45         } 
    46  
    47         void pop() { 
    48             synchronized (mutex) { 
    49                 if (!head) { 
    50                     return; 
    51                 } 
    52                 head = head->next; 
    53             } 
    54         } 
    55  
    56         EventBase* top() { 
    57             synchronized (mutex) { 
    58                 return head; 
    59             } 
    60  
    61             return NULL; 
    62         } 
    63  
    64         void clear() { 
    65             synchronized (mutex) { 
     10    template <typename Child> 
     11        class Module : public ModuleCommon<Module<Child>, MIL_DEFAULT_THREAD> { 
     12    public: 
     13        Tls tls; 
     14        MIL_CRTP_CLASS_MEMBERS; 
     15 
     16    private: 
     17        class EventBase : public boost::noncopyable { 
     18        public: 
     19            void (*execute)(void* event, void* target); 
     20            intptr_t owner_id; 
     21            EventBase* next; 
     22        }; 
     23 
     24        class EventList : public boost::noncopyable { 
     25            EventBase* head; 
     26            EventBase* tail; 
     27            Mutex mutex; 
     28        public: 
     29            EventList() { 
    6630                head = NULL; 
    6731                tail = NULL; 
    6832            } 
    69         } 
    70     }; 
    71  
    72  
    73     /* 
    74     class EventBase : public boost::intrusive::slist_base_hook<>, public boost::noncopyable 
    75     { 
    76     public: 
    77         void (*execute)(void* event, void* target); 
    78         intptr_t owner_id; 
    79     }; 
    80  
    81     class EventList : public boost::noncopyable 
    82     { 
    83         boost::intrusive::slist<EventBase, boost::intrusive::constant_time_size<false>, boost::intrusive::cache_last<true> > l; 
    84         boost::details::pool::default_mutex m; 
    85         typedef boost::details::pool::guard<boost::details::pool::default_mutex> guard; 
    86     public: 
    87         void push(EventBase& e) 
    88         { 
    89             guard g(m); 
    90             l.push_back(e); 
    91         } 
    92  
    93         void pop() 
    94         { 
    95             guard g(m); 
    96             l.pop_front(); 
    97         } 
    98  
    99         EventBase* top() 
    100         { 
    101             guard g(m); 
    102             if (l.size() == 0) 
    103             { 
     33 
     34            void push(EventBase& e) { 
     35                synchronized (mutex) { 
     36                    e.next = NULL; 
     37                    if (head == NULL) { // tail == NULL 
     38                        head = &e; 
     39                        tail = &e; 
     40                        return; 
     41                    } 
     42                    tail->next = &e; 
     43                    tail = &e; 
     44                } 
     45            } 
     46 
     47            void pop() { 
     48                synchronized (mutex) { 
     49                    if (!head) { 
     50                        return; 
     51                    } 
     52                    head = head->next; 
     53                } 
     54            } 
     55 
     56            EventBase* top() { 
     57                synchronized (mutex) { 
     58                    return head; 
     59                } 
     60 
    10461                return NULL; 
    10562            } 
    106             return &l.front(); 
    107         } 
    108  
    109         void clear() 
    110         { 
    111             guard g(m); 
    112             l.clear(); 
    113         } 
    114     }; 
    115     */ 
    116  
    117     template <typename T> 
    118     class Event : public EventBase { 
    119     public: 
    120         typedef T DataType; 
    121         T data; 
    122     }; 
    123  
    124     friend class Module_test; 
    125  
    126 private: 
    127     EventList list; 
    128     Conditional c; 
    129     bool repost; 
    130     bool breakLoopRequest; 
    131     atomic<bool> isWaiting; 
    132  
    133 public: 
     63 
     64            void clear() { 
     65                synchronized (mutex) { 
     66                    head = NULL; 
     67                    tail = NULL; 
     68                } 
     69            } 
     70        }; 
     71 
     72 
     73        /* 
     74          class EventBase : public boost::intrusive::slist_base_hook<>, public boost::noncopyable 
     75          { 
     76          public: 
     77          void (*execute)(void* event, void* target); 
     78          intptr_t owner_id; 
     79          }; 
     80 
     81          class EventList : public boost::noncopyable 
     82          { 
     83          boost::intrusive::slist<EventBase, boost::intrusive::constant_time_size<false>, boost::intrusive::cache_last<true> > l; 
     84          boost::details::pool::default_mutex m; 
     85          typedef boost::details::pool::guard<boost::details::pool::default_mutex> guard; 
     86          public: 
     87          void push(EventBase& e) 
     88          { 
     89          guard g(m); 
     90          l.push_back(e); 
     91          } 
     92 
     93          void pop() 
     94          { 
     95          guard g(m); 
     96          l.pop_front(); 
     97          } 
     98 
     99          EventBase* top() 
     100          { 
     101          guard g(m); 
     102          if (l.size() == 0) 
     103          { 
     104          return NULL; 
     105          } 
     106          return &l.front(); 
     107          } 
     108 
     109          void clear() 
     110          { 
     111          guard g(m); 
     112          l.clear(); 
     113          } 
     114          }; 
     115        */ 
     116 
     117        template <typename T> 
     118            class Event : public EventBase { 
     119        public: 
     120            typedef T DataType; 
     121            T data; 
     122        }; 
     123 
     124        friend class Module_test; 
     125 
     126    private: 
     127        EventList list; 
     128        Conditional c; 
     129        bool repost; 
     130        bool breakLoopRequest; 
     131        atomic<bool> isWaiting; 
     132 
     133    public: 
    134134    Module() : tls(this->thread_id), repost(false), breakLoopRequest(false), isWaiting(false) { 
    135     } 
    136  
    137     void run() { 
    138         MIL_MODULE_GET_SUPER_CHILD(*this).loop(); 
    139     } 
     135        } 
     136 
     137        void run() { 
     138            MIL_MODULE_GET_SUPER_CHILD(*this).loop(); 
     139        } 
    140140     
    141 protected: 
    142     void repostEvent() { 
    143         repost = true; 
    144     } 
    145  
    146     template <typename Data, typename Sender> 
    147     static void dispatcher(void* event_, void* target_) { 
    148         typedef Child Target; 
    149  
    150         if (!event_ || !target_) { 
    151             return; 
    152         } 
    153  
    154         // XXX type safety?? 
    155         Target& target = *static_cast<Target*>(target_); 
    156         Event<Data>& event = *static_cast<Event<Data>*>(event_); 
    157         target.list.pop(); 
    158         target.repost = false; 
    159         ModuleExecuteProxy::execute<Data, Target>(event.data, target); 
    160         if (target.repost) { 
    161             target.list.push(event); 
    162             return; 
    163         } 
    164  
    165         freeEvent<Sender>(event, target); 
    166     } 
    167  
    168 public: 
    169     template <typename T, typename Sender> 
    170     //void post(const T& event, Sender& sender, void* memory, intptr_t owner_id) 
    171     void post(const T& event, Sender&, void* memory, intptr_t owner_id) { 
    172         Event<T>* e = new(memory) Event<T>; 
    173         e->data = event; 
    174         e->execute = dispatcher<T, Sender>; 
    175         e->owner_id = owner_id; 
    176  
    177         list.push(*e); 
    178         if (isWaiting.load()) { 
    179             c.signal(); 
    180         } 
    181     } 
    182  
    183     template <typename T, typename Sender> 
    184     void post(const T& event, Sender& sender) { 
    185         pool::Producer& producer = sender.tls.producer; 
    186         void* memory = producer.malloc<sizeof(Event<T>)>(); 
    187         if (memory == NULL) { 
    188             debug << "can't allocate event memory"; 
    189             return; 
    190         } 
    191  
    192         post(event, sender, memory, sender.tls.thread_id); 
    193     } 
    194 public: 
    195     void destroy() { 
    196         breakLoopRequest = true; 
    197     } 
    198  
    199     void requestExit(void* event_memory) { 
    200         list.clear(); 
    201         exitNotifier.tls.flush(); 
    202         ExitEvent e; 
    203         post(e, exitNotifier, event_memory, exitNotifier.tls.thread_id); 
    204     } 
    205  
    206     ~Module() { 
    207         do_auto_join(); 
    208     } 
    209  
    210     void execute_front() { 
    211         EventBase* e = list.top(); 
    212         if (e) { 
    213             e->execute((void*)e, (void*)this); 
    214         } 
    215     } 
    216  
    217 protected: 
    218     void loop() { 
    219         while (!breakLoopRequest) { 
     141    protected: 
     142        void repostEvent() { 
     143            repost = true; 
     144        } 
     145 
     146        template <typename Data, typename Sender> 
     147            static void dispatcher(void* event_, void* target_) { 
     148            typedef Child Target; 
     149 
     150            if (!event_ || !target_) { 
     151                return; 
     152            } 
     153 
     154            // XXX type safety?? 
     155            Target& target = *static_cast<Target*>(target_); 
     156            Event<Data>& event = *static_cast<Event<Data>*>(event_); 
     157            target.list.pop(); 
     158            target.repost = false; 
     159            ModuleExecuteProxy::execute<Data, Target>(event.data, target); 
     160            if (target.repost) { 
     161                target.list.push(event); 
     162                return; 
     163            } 
     164 
     165            if (event.owner_id == target.thread_id) { 
     166                // ReturnMemoryEvent 
     167                pool::ReturnMemoryProxy::free<Data>( 
     168                    &event, target.tls.producer, pool::Class2Blocks<Event<Data> >::value); 
     169                return; 
     170            } 
     171         
     172            pool::MemoryList* m = target.tls.consumer.pop(event.owner_id); 
     173            if (!m) { 
     174                target.tls.consumer.store(&event); 
     175                return; 
     176            } 
     177         
     178            pool::ReturnMemoryEvent<sizeof(Event<Data>)> e; 
     179            e.memory = m; 
     180            void* t = threads[event.owner_id].load(); 
     181            if (!t) { 
     182                return; 
     183            } 
     184            (reinterpret_cast<Sender*>(t))->post(e, target, (void*)&event, event.owner_id); 
     185        } 
     186 
     187    public: 
     188        template <typename T, typename Sender> 
     189            //void post(const T& event, Sender& sender, void* memory, intptr_t owner_id) 
     190            void post(const T& event, Sender&, void* memory, intptr_t owner_id) { 
     191            Event<T>* e = new(memory) Event<T>; 
     192            e->data = event; 
     193            e->execute = dispatcher<T, Sender>; 
     194            e->owner_id = owner_id; 
     195 
     196            list.push(*e); 
     197            if (isWaiting.load()) { 
     198                c.signal(); 
     199            } 
     200        } 
     201 
     202        template <typename T, typename Sender> 
     203            void post(const T& event, Sender& sender) { 
     204            pool::Producer& producer = sender.tls.producer; 
     205            void* memory = producer.malloc<sizeof(Event<T>)>(); 
     206            if (memory == NULL) { 
     207                halt << "can't allocate event memory"; 
     208                return; 
     209            } 
     210 
     211            post(event, sender, memory, sender.tls.thread_id); 
     212        } 
     213    public: 
     214        void destroy() { 
     215            breakLoopRequest = true; 
     216        } 
     217 
     218        void requestExit(void* event_memory) { 
     219            list.clear(); 
     220            exitNotifier.tls.flush(); 
     221            ExitEvent e; 
     222            post(e, exitNotifier, event_memory, exitNotifier.tls.thread_id); 
     223        } 
     224 
     225        ~Module() { 
     226            do_auto_join(); 
     227        } 
     228 
     229        bool execute_front() { 
    220230            EventBase* e = list.top(); 
    221231            if (e) { 
    222232                e->execute((void*)e, (void*)this); 
    223             } else { 
    224                 isWaiting.store(true); 
    225                 c.wait(); 
    226                 isWaiting.store(false); 
    227             } 
    228         } 
    229         breakLoopRequest = false; 
    230     } 
    231 }; 
     233                return true; 
     234            } 
     235            return false; 
     236        } 
     237 
     238    protected: 
     239        void loop() { 
     240            while (!breakLoopRequest) { 
     241                EventBase* e = list.top(); 
     242                if (e) { 
     243                    e->execute((void*)e, (void*)this); 
     244                } else { 
     245                    isWaiting.store(true); 
     246                    c.wait(); 
     247                    isWaiting.store(false); 
     248                } 
     249            } 
     250            breakLoopRequest = false; 
     251        } 
     252    }; 
    232253 
    233254} 
  • lang/objective-cplusplus/i3/trunk/src/mil/include/mil/ModuleCommon.h

    r34723 r34769  
    22 
    33#include "Thread.h" 
     4#include "Memory.h" 
    45 
    56namespace mil { 
    6 namespace pool { 
    7  
    8 /* 
    9 template <int T> 
    10 struct SizeFixer 
    11 { 
    12     static const int SIZE = ((T <= sizeof(void*) *  3) ? sizeof(void*) *  3 : 
    13          ((T <= sizeof(void*) *  6) ? sizeof(void*) *  6 : 
    14           ((T <= sizeof(void*) * 16) ? sizeof(void*) * 16 : 
    15            ((T <= sizeof(void*) * 48) ? sizeof(void*) * 48 : 
    16 //        ((T <= 1024) ? 1024 : 
    17             0)))); 
    18 //); 
    19 }; 
    20 */ 
    21  
    22 class MemoryList { 
    23 public: 
    24     MemoryList* next; 
    25     intptr_t blocks; 
    26 }; 
    27  
    28 const int BLOCK_SIZE = sizeof(void*) * 3; 
    29 const int MALLOC_BLOCKS_THESHOLD = 5; 
    30  
    31 template <size_t Blocks> 
    32 struct Blocks2Bytes { 
    33     enum { 
    34         value = Blocks *  BLOCK_SIZE, 
    35     }; 
    36 }; 
    37  
    38 template <size_t S> 
    39 struct Bytes2Blocks { 
    40     enum { 
    41         value = ((S - 1) / BLOCK_SIZE) + 1 
    42     }; 
    43 }; 
    44  
    45 template <class T> 
    46 struct Class2Blocks { 
    47     enum { 
    48         value = Bytes2Blocks<sizeof(T)>::value 
    49     }; 
    50 }; 
    51  
    52 template <int BYTES_> 
    53 struct ReturnMemoryEvent { 
    54     enum { 
    55         BLOCKS = Bytes2Blocks<BYTES_>::value, 
    56         BYTES = BYTES_, 
    57     }; 
    58      
    59     typedef SFINAE_CONDITION IsReturnMemoryEvent; 
    60  
    61     MemoryList* memory; 
    62 }; 
    63  
    64 //#ifdef _DEBUGaio 
    65 #define DEBUG_PRODUCER 
    66 //#endif 
    67 class Producer { 
    68 public: 
    69     boost::pool<> p; 
    70     const intptr_t thread_id; 
    71     Producer(intptr_t thread_id = 0) : p(BLOCK_SIZE), thread_id(thread_id) { 
    72     } 
    73  
    74     struct DebugInfo { 
    75         unsigned int os_thread_id; 
    76         int mil_thread_id; 
    77         int blocks; 
    78     }; 
    79 #ifdef DEBUG_PRODUCER 
    80     std::list<void*> malloc_history; 
    81 #endif 
    82     template <int SIZE> 
    83     void* malloc() 
    84 #ifdef DEBUG_PRODUCER 
    85     { 
    86         char* memory = (char*)::malloc(SIZE + sizeof(DebugInfo)); 
    87         if (!memory) { 
    88             halt << "can't allocate memory"; 
    89         } 
    90         //malloc_history.push_back((void*)memory); 
    91         DebugInfo* d = (DebugInfo*)memory; 
    92         d->os_thread_id  = GetCurrentThreadId(); 
    93         d->mil_thread_id = thread_id; 
    94         d->blocks        = Bytes2Blocks<SIZE>::value; 
    95         memory += sizeof(DebugInfo); 
    96         return memory; 
    97     } 
    98 #else 
    99     { 
    100         int blocks = Bytes2Blocks<SIZE>::value; 
    101         if (blocks > MALLOC_BLOCKS_THESHOLD) { 
    102             return ::malloc(SIZE); 
    103         } else { 
    104             return p.ordered_malloc(blocks); 
    105         } 
    106     } 
    107 #endif 
    108  
    109     void free2(void* memory, int blocks) 
    110 #ifdef DEBUG_PRODUCER 
    111     { 
    112         memory = (void*)((char*)memory - sizeof(DebugInfo)); 
    113         /* 
    114         if (malloc_history.find(memory) == std::npos) { 
    115             using namespace std; 
    116             stringstream stream; 
    117             for (int i = 1; !malloc_history.empty; malloc_history.pop_front(), i++) { 
    118                 stream << dec << i << ": " << hex << malloc_history.front() << endl; 
    119             } 
    120             halt << "invalid address" << endl << stream; 
    121         } 
    122         */ 
    123  
    124         DebugInfo* d = (DebugInfo*)memory; 
    125         if (d->os_thread_id != GetCurrentThreadId()) { 
    126             halt << "d->os_thread_id != GetCurrentThreadId(), " 
    127                  << d->os_thread_id << " != " << GetCurrentThreadId(); 
    128         } 
    129         if (d->mil_thread_id != thread_id) { 
    130             halt << "d->mil_thread_id == thread_id, " 
    131                  << d->mil_thread_id << " != " << thread_id; 
    132         } 
    133         if (d->blocks != blocks) { 
    134             halt << "d->blocks != blocks, " 
    135                  << d->blocks << " != " << blocks; 
    136         } 
    137         ::free((void*)memory); 
    138     } 
    139 #else 
    140     { 
    141         if (blocks > MALLOC_BLOCKS_THESHOLD) { 
    142             ::free((void*)memory); 
    143         } else { 
    144             p.free(memory, blocks); 
    145         } 
    146     } 
    147 #endif 
    148  
    149     void free(MemoryList* m) { 
    150         MemoryList* current = m; 
    151         for (;;) { 
    152             if (!current) { 
    153                 break; 
    154             } 
    155             MemoryList* next = current->next; 
    156             free2(current, current->blocks); 
    157             current = next; 
    158         } 
    159     } 
    160 }; 
    161  
    162 struct ReturnMemoryProxy { 
    163     template <typename T> 
    164     static void free_body(void* m, mil::pool::Producer& p, int blocks, typename T::IsReturnMemoryEvent) { 
    165         p.free2(m, T::BLOCKS); 
    166     } 
    167  
    168     template <typename T> 
    169     static void free_body(void* m, mil::pool::Producer& p, int blocks, ...) { 
    170         p.free2(m, blocks); 
    171     } 
    172  
    173     template <typename T> 
    174     static void free(void* m, mil::pool::Producer& p, int blocks) { 
    175         free_body<T>(m, p, blocks, SFINAE_DUMMY_VALUE); 
    176     } 
    177 }; 
    178  
    179 class Consumer { 
    180     MemoryList* heads[MIL_MAX_THREADS]; 
    181     int sizes[MIL_MAX_THREADS]; 
    182  
    183     enum { 
    184         MAX_STORES = 20, 
    185     }; 
    186  
    187 public: 
    188     Consumer() { 
    189         memset((void*)heads, 0, sizeof(heads)); 
    190         memset((void*)sizes, 0, sizeof(sizes)); 
    191     } 
    192  
    193     MemoryList* pop(int owner_id) { 
    194         if (sizes[owner_id] < MAX_STORES) { 
    195             return NULL; 
    196         } 
    197         MemoryList* result = heads[owner_id]; 
    198         heads[owner_id] = 0; 
    199         sizes[owner_id] = 0; 
    200         return result; 
    201     } 
    202  
    203     template <class T> 
    204     void store(T* mem) { 
    205         int owner_id = mem->owner_id; 
    206         MemoryList* l = (MemoryList*)mem; 
    207         int blocks = Class2Blocks<T>::value; 
    208         l->blocks = blocks; 
    209  
    210         if (blocks > MALLOC_BLOCKS_THESHOLD) { 
    211 #ifdef DEBUG_PRODUCER 
    212             mem = (T*)((char*)mem - sizeof(Producer::DebugInfo)); 
    213 #endif 
    214             free(mem); 
    215             return; 
    216         } 
    217  
    218         l->next = heads[owner_id]; 
    219         heads[owner_id] = l; 
    220         sizes[owner_id]++; 
    221     } 
    222 }; 
    223 } 
    2247 
    2258class Tls { 
     
    25336    } 
    25437}; 
    255  
    256 template <class Sender, class Event, class Target> 
    257 void freeEvent(Event& event, Target& target) { 
    258     if (event.owner_id == target.thread_id) { 
    259         mil::pool::ReturnMemoryProxy::free<typename Event::DataType>( 
    260             &event, target.tls.producer, mil::pool::Class2Blocks<Event>::value); 
    261         return; 
    262     } 
    263  
    264     pool::MemoryList* m = target.tls.consumer.pop(event.owner_id); 
    265     if (!m) { 
    266         target.tls.consumer.store(&event); 
    267         return; 
    268     } 
    269  
    270     pool::ReturnMemoryEvent<sizeof(Event)> e; 
    271     e.memory = m; 
    272     void* t = threads[event.owner_id].load(); 
    273     if (!t) { 
    274         return; 
    275     } 
    276     (reinterpret_cast<Sender*>(t))->post(e, target, (void*)&event, event.owner_id); 
    277 } 
    27838 
    27939struct ExitEvent { 
  • lang/objective-cplusplus/i3/trunk/src/mil/include/mil/gui-windows/GuiModule.h

    r34723 r34769  
    1212 
    1313const UINT WM_MIL_GUIMODULE = WM_APP+100; 
    14  
    15  
    16 template <class EventData> 
    17 size_t moudamepo_sizeof_body(typename EventData::IsReturnMemoryEvent) { 
    18     return EventData::BYTES; 
    19 } 
    20  
    21 template <class EventData> 
    22 size_t moudamepo_sizeof_body(...) { 
    23     return sizeof(EventData); 
    24 } 
    25  
    26 template <class EventData> 
    27 size_t moudamepo_sizeof() { 
    28     return moudamepo_sizeof_body<EventData>(SFINAE_DUMMY_VALUE); 
    29 } 
    3014 
    3115/** 
     
    10286        Target& target = *static_cast<Target*>(target_); 
    10387        target.repost = false; 
    104         if (moudamepo_sizeof<Data>() <= sizeof(LPARAM)) { 
     88        if (return_memory_considered_sizeof<Data>() <= sizeof(LPARAM)) { 
    10589            Data data; 
    10690            memcpy(&data, &event_, sizeof(data)); 
     
    265249        if (memory == NULL) { 
    266250            // XXX 
     251            halt << "can't allocate event memory (GuiModule)"; 
    267252            return; 
    268253        } 
     
    313298    } 
    314299 
    315     void execute_front() { 
     300    bool execute_front() { 
    316301        MSG msg = {}; 
    317302        unsigned int loop = 10000; 
     
    320305            DispatchMessage(&msg); 
    321306            if (msg.message == WM_MIL_GUIMODULE) { 
    322                 return; 
     307                return true; 
    323308            } 
    324309            if (loop-- == 0) { 
    325                 return; 
    326             } 
    327         } 
     310                return false; 
     311            } 
     312        } 
     313        return false; 
    328314    } 
    329315 
  • lang/objective-cplusplus/i3/trunk/src/mil/src/Test8.cpp

    r34448 r34769  
    114114} 
    115115 
     116QT_TEST(test_dasadsffhoiaaaa7778aasdf) { 
     117    using namespace std; 
     118    vector<int> v1, v2, v3; 
     119    v1.reserve(12345); 
     120    QT_CHECK_NOT_EQUAL(v1.capacity(), v2.capacity()); 
     121    v2 = v1; 
     122    QT_CHECK_NOT_EQUAL(v1.capacity(), v2.capacity());     
     123} 
     124 
  • lang/objective-cplusplus/i3/trunk/src/mil/src/Test9.cpp

    r34612 r34769  
    5959        } 
    6060 
    61         for (int i = 0; i < 500; i++) { 
     61        for (int i = 0; i < 50000; i++) { 
    6262            SmallEvent e; 
    6363            e.data = 5; 
     
    199199    } 
    200200}; 
     201 
     202 
    201203} 
    202204 
     
    254256    } 
    255257} 
    256  
    257 /* 
    258  
    259258QT_TEST(test_adifjadfioajdfaoidffgzg8) { 
    260259    for (int i = 0; i < 5; i++) { 
     
    356355} 
    357356 
    358 */ 
  • lang/objective-cplusplus/i3/trunk/windows/release.sh

    r34697 r34769  
    1313export CFLAGS="-O3 -DNDEBUG" 
    1414export CXXFLAGS="$CFLAGS"  
    15 export LDFLAGS="-s" 
     15export LDFLAGS="-s -L/usr/local/$CROSS_HOST/lib" 
    1616# cross compile: 
    1717# *binutils 
     
    1919# *install mingwrt & w32api binaries -> /usr/local/$CROSS_HOST 
    2020# *gcc 
    21 # ./configure --target=$CROSS_HOST --enable-languages=c,c++ && make && make install 
     21# ./configure --target=$CROSS_HOST --enable-languages=c,c++ --disable-libada --disable-libssp && make && make install 
    2222# *iconv 
    2323# ./configure --prefix=/usr/local/$CROSS_HOST --host=$CROSS_HOST --disable-shared && make && make install 
  • lang/objective-cplusplus/i3/trunk/windows/resources/i3.rc

    r34638 r34769  
    1 // Generated by ResEdit 1.4.4.17 
    2 // Copyright (C) 2006-2008 
    3 // http://www.resedit.net 
     1// -*- coding: utf-16-le-dos -*- 
    42 
    53#include "resource.h"