AVR: aversive_10-03-12/projects/example2/main.c Source File

00001 /*  
00002  *  Copyright Droids Corporation, Microb Technology, Eirbot (2005)
00003  * 
00004  *  This program is free software; you can redistribute it and/or modify
00005  *  it under the terms of the GNU General Public License as published by
00006  *  the Free Software Foundation; either version 2 of the License, or
00007  *  (at your option) any later version.
00008  *
00009  *  This program is distributed in the hope that it will be useful,
00010  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012  *  GNU General Public License for more details.
00013  *
00014  *  You should have received a copy of the GNU General Public License
00015  *  along with this program; if not, write to the Free Software
00016  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00017  *
00018  *  Revision : $Id: main.c,v 1.6 2007-06-11 10:03:26 zer0 Exp $
00019  *
00020  */
00021 
00022 #include <aversive.h>
00023 #include <aversive/list.h>
00024 
00025 #include <uart.h>
00026 
00027 #include <stdio.h>
00028 #include <string.h>
00029 
00030 LIST_TYPEDEF(my_list_type, u08, 4);
00031 LIST_TYPEDEF(my_another_list_type, u08, 10);
00032 
00033 void dumplist(struct generic_list * l)
00034 {
00035         u08 i;
00036 
00037         for(i=0 ; i < l->hdr.size ; i++)
00038                 printf( (i != l->hdr.size-1 ? 
00039                                     "|-------" : "|-------|"CR) );
00040 
00041         for(i=0 ; i < l->hdr.size ; i++) {
00042                 if (( i < l->hdr.beg_indice ) && (l->hdr.cur_size > 0)) {
00043                         if (i < (l->hdr.beg_indice 
00044                                     + l->hdr.cur_size)
00045                             % l->hdr.size) {
00046                                 printf("   %.3d  ", l->elt[i]);
00047                                           
00048                         }
00049                         else {
00050                                 printf("   XXX  ");
00051                         }
00052                 }
00053                 else if (l->hdr.cur_size > 0){
00054                         if (i < l->hdr.beg_indice + l->hdr.cur_size) {
00055                                 printf("   %.3d  ", l->elt[i]);
00056                         }
00057                         else {
00058                                 printf("   XXX  ");
00059                         }
00060                 }
00061                 else {
00062                         printf("   XXX  ");
00063                 }
00064         }
00065         
00066         printf("     cur_size=%d"CR,l->hdr.cur_size);
00067 
00068         for(i=0 ; i < l->hdr.size ; i++)
00069                 printf( (i != l->hdr.size-1 ? 
00070                                     "|-------" : "|-------|"CR) );
00071 
00072         for(i=0 ; i < l->hdr.size ; i++)
00073                 {
00074                         if((i == l->hdr.beg_indice) && (l->hdr.cur_size <= 1))
00075                                 printf(" beg^end");
00076                         else if(i == l->hdr.beg_indice) 
00077                                 printf("  beg^  ");
00078                         else if((l->hdr.cur_size > 1) && 
00079                                    (i == ((l->hdr.beg_indice + l->hdr.cur_size -1)
00080                                                 % l->hdr.size)))
00081                                 printf("  end^  ");
00082                         else
00083                                 printf("        ");
00084                         printf( (i != l->hdr.size-1 ? 
00085                                     "" : CR) );
00086                 }        
00087 
00088         for(i=0 ; i < l->hdr.size ; i++)
00089                 {
00090                         if(i == ((l->hdr.beg_indice + l->hdr.read_cursor)
00091                                                 % l->hdr.size))
00092                                 printf("  cur^  ");
00093                         else
00094                                 printf("        ");
00095                         printf( (i != l->hdr.size-1 ? 
00096                                     "" : CR) );
00097                 }        
00098 
00099 }
00100 
00101 int main(void)
00102 {
00103         u08 tmp=0;
00104         u08 tab1[4]= "0123";
00105         u08 tab2[4];
00106 
00107 #ifndef HOST_VERSION 
00108 /*      uart_init(); */
00109 /*      fdevopen((int (*)(char))uart0_send,(int (*)(void))uart0_recv,0); */
00110 #endif
00111         my_list_type my_list ;
00112         my_another_list_type another_list ;
00113 
00114         LIST_INIT(my_list, 0);
00115         LIST_INIT(another_list, 8);
00116 
00117         dumplist((struct generic_list *)&my_list);
00118         printf(CR CR);
00119         
00120         LIST_PUSH_END(my_list, 2);
00121         dumplist((struct generic_list *)&my_list);
00122         printf(CR CR);
00123 
00124         LIST_PUSH_END(my_list, 3);
00125         dumplist((struct generic_list *)&my_list);
00126         printf(CR CR);
00127 
00128         LIST_PUSH_START(my_list, 1);
00129         dumplist((struct generic_list *)&my_list);
00130         printf(CR CR);
00131 
00132         LIST_PUSH_END(my_list, 4);
00133         dumplist((struct generic_list *)&my_list);
00134         printf(CR CR);
00135 
00136         LIST_PUSH_END(my_list, 5);
00137         dumplist((struct generic_list *)&my_list);
00138         printf(CR CR);
00139 
00140 
00141         LIST_PULL_END(my_list, &tmp);
00142         dumplist((struct generic_list *)&my_list);
00143         printf("tmp = %d"CR CR CR,tmp);
00144 
00145 
00146         LIST_READ_START(my_list, &tmp);
00147         dumplist((struct generic_list *)&my_list);
00148         printf("tmp = %d"CR CR CR,tmp);
00149 
00150         LIST_READ_END(my_list, &tmp);
00151         dumplist((struct generic_list *)&my_list);
00152         printf("tmp = %d"CR CR CR,tmp);
00153         
00154         LIST_READ_GOTO(my_list, &tmp, 0);
00155         dumplist((struct generic_list *)&my_list);
00156         printf("tmp = %d"CR CR CR,tmp);
00157 
00158         LIST_READ_GOTO(my_list, &tmp, 1);
00159         dumplist((struct generic_list *)&my_list);
00160         printf("tmp = %d"CR CR CR,tmp);
00161 
00162         LIST_READ_GOTO(my_list, &tmp, 2);
00163         dumplist((struct generic_list *)&my_list);
00164         printf("tmp = %d"CR CR CR,tmp);
00165 
00166         LIST_READ_GOTO(my_list, &tmp, 3);
00167         dumplist((struct generic_list *)&my_list);
00168         printf("tmp = %d"CR CR CR,tmp);
00169 
00170         LIST_READ_MOVE(my_list, &tmp, 1);
00171         dumplist((struct generic_list *)&my_list);
00172         printf("tmp = %d"CR CR CR,tmp);
00173 
00174         LIST_READ_MOVE(my_list, &tmp, 1);
00175         dumplist((struct generic_list *)&my_list);
00176         printf("tmp = %d"CR CR CR,tmp);
00177 
00178         LIST_READ_MOVE(my_list, &tmp, 1);
00179         dumplist((struct generic_list *)&my_list);
00180         printf("tmp = %d"CR CR CR,tmp);
00181 
00182         LIST_READ_MOVE(my_list, &tmp, 1);
00183         dumplist((struct generic_list *)&my_list);
00184         printf("tmp = %d"CR CR CR,tmp);
00185 
00186         LIST_READ_MOVE(my_list, &tmp, 2);
00187         dumplist((struct generic_list *)&my_list);
00188         printf("tmp = %d"CR CR CR,tmp);
00189 
00190         LIST_READ_MOVE(my_list, &tmp, 3);
00191         dumplist((struct generic_list *)&my_list);
00192         printf("tmp = %d"CR CR CR,tmp);
00193 
00194         LIST_READ_MOVE(my_list, &tmp, 1);
00195         dumplist((struct generic_list *)&my_list);
00196         printf("tmp = %d"CR CR CR,tmp);
00197 
00198         LIST_READ_MOVE(my_list, &tmp, 2);
00199         dumplist((struct generic_list *)&my_list);
00200         printf("tmp = %d"CR CR CR,tmp);
00201 
00202         LIST_READ_MOVE(my_list, &tmp, 3);
00203         dumplist((struct generic_list *)&my_list);
00204         printf("tmp = %d"CR CR CR,tmp);
00205 
00206         LIST_READ_MOVE(my_list, &tmp, -1);
00207         dumplist((struct generic_list *)&my_list);
00208         printf("tmp = %d"CR CR CR,tmp);
00209 
00210         LIST_READ_MOVE(my_list, &tmp, -2);
00211         dumplist((struct generic_list *)&my_list);
00212         printf("tmp = %d"CR CR CR,tmp);
00213 
00214         LIST_READ_MOVE(my_list, &tmp, -3);
00215         dumplist((struct generic_list *)&my_list);
00216         printf("tmp = %d"CR CR CR,tmp);
00217 
00218 
00219 
00220         LIST_PULL_END(my_list, &tmp);
00221         dumplist((struct generic_list *)&my_list);
00222         printf("tmp = %d"CR CR CR,tmp);
00223 
00224         LIST_PULL_START(my_list, &tmp);
00225         dumplist((struct generic_list *)&my_list);
00226         printf("tmp = %d"CR CR CR,tmp);
00227 
00228         LIST_PULL_START(my_list, &tmp);
00229         dumplist((struct generic_list *)&my_list);
00230         printf("tmp = %d"CR CR CR,tmp);
00231 
00232         LIST_PULL_START(my_list, &tmp);
00233         dumplist((struct generic_list *)&my_list);
00234         printf(CR CR);
00235         printf(CR CR);
00236         
00237 
00238         LIST_ARRAY_PUSH_START(another_list, tab1, 4);
00239         dumplist((struct generic_list *)&another_list);
00240         printf(CR CR);
00241 
00242         LIST_ARRAY_PUSH_END(another_list, "abcde", 5);
00243         dumplist((struct generic_list *)&another_list);
00244         printf(CR CR);
00245 
00246         LIST_ARRAY_PULL_START(another_list, tab2, 4);
00247         dumplist((struct generic_list *)&another_list);
00248         printf(CR CR);
00249 
00250         LIST_ARRAY_PULL_END(another_list, tab2, 2);
00251         dumplist((struct generic_list *)&another_list);
00252         printf(CR CR);
00253 
00254         LIST_ALIGN_LEFT(another_list);
00255         dumplist((struct generic_list *)&another_list);
00256         printf(CR CR);
00257 
00258 
00259         LIST_INIT(my_list,0);
00260         dumplist((struct generic_list *)&my_list);
00261         printf(CR CR);
00262 
00263         LIST_ARRAY_PUSH_START(my_list, tab1, 3);
00264         dumplist((struct generic_list *)&my_list);
00265         printf(CR CR);
00266         
00267         LIST_ALIGN_LEFT(my_list);
00268         dumplist((struct generic_list *)&my_list);
00269         printf(CR CR);
00270 
00271 
00272         return 0;
00273 }