#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <string.h>
/****************************
*
* 模仿Linux 下的 cal命令
*
* cal
* 无参数显示当前月日历
* -h 帮助信息
* -m 指定月(1--12)
* -y 指定年(>1900)
* -j 显示本年的第几天，默认显示日期
* -y,-m 缺省为当前年、月
*
* for example:
*
* $>cal -y 1997 -m 12
* $>cal -y 1997
* $>cal -m 12
* $>cal -y 2008 -j
*
*
* 操作系统对year的限制不同
* Window ：一般从1970~2038
* Linux : 基本没有限制
*
*
*
* author:zhanglihai
* date : 2008/02/20
* **************************/
//定义月的英文描述
char *month_name_en[12]={"January","February","March","April","May","June","July","August","September","October","November","December"};
char *week_name_en[7]={"Sun", "Mon", "Tue","Wed", "Thu", "Fri", "Sat"};
char *animals[12] = { "鼠", "牛", "虎", "兔",
"龙", "蛇", "马", "羊", "猴", "鸡", "狗", "猪" };
int month_max_day[12]={31,28,31,30,31,30,31,31,30,31,30,31};
typedef struct tm Date;
typedef struct tm *PDate;



void printHelp(){
printf("\n模仿Linux 下的 cal命令"
"\n\n"
"cal\n"
"无参数显示当前月日历"
"\n\n"
"-h 帮助信息\n"
"-m 指定月(1--12)\n"
"-y 指定年(>1900)\n"
"-j 显示本年的第几天，默认显示日期\n"
"\n\n"
"-y,-m 缺省为当前年、月\n"
"\n"
"for example:\n"
"$>cal -y 1997 -m 12\n"
"$>cal -y 1997\n"
"$>cal -m 12\n"
"$>cal -y 2008 -j \n"
"\n"
"操作系统对year的限制不同\n"
"Window ：一般从1970~2038\n"
"Linux : 基本没有限制\n"
"\n\n"
" author : zhanglihai\n"
" date : 2008/02/20\n");
}


int monthMaxDay(int y,int m){
int y1=y+1900;
if(m==1)
{
if((y1%400==0)||(y1%4==0&&y1%100!=0))
return 29;
}
return month_max_day[m];
}

void printYearCal(PDate pdate,int fmt)
{
int i,j,w,left;
int m_len;
int max_day1,max_day2;
int day1,day2,gday1,gday2;
int wday1,wday2;
int year=pdate->tm_year;
time_t _tm;
PDate _pdate;
pdate->tm_mon=0;
pdate->tm_mday=1;
_tm=mktime(pdate);
if(_tm==-1)
{
printf("can't mktime . \n");
printf("-h help info.\n");
return;
}
printf("\n%*d %s\n\n",(27*2-4*2-4)/2+10,pdate->tm_year+1900,animals[((pdate->tm_year+1900)-4)%12]);
_pdate=localtime(&_tm);
wday1=_pdate->tm_wday;
day1=day2=gday1=gday2=1;
for(i=0;i<12;i+=2)
{
day1=day2=1;
max_day1=monthMaxDay(year,i);
max_day2=monthMaxDay(year,i+1);
wday2=(max_day1-(7-wday1))%7;
//输出月英文名字
m_len=strlen(month_name_en[i]);
left=(27-m_len)/2+m_len;
printf("%*s",left,month_name_en[i]);
//剩下的位置用空格补齐
for(j=0;j<27-left;j++)
printf(" ");
//输出4个空格作为间隔
for(j=0;j<4;j++)
printf(" ");
//输出横排第二个月的名字
m_len=strlen(month_name_en[i+1]);
left=(27-m_len)/2+m_len;
printf("%*s\n",left,month_name_en[i+1]);

//开始输出星期的英文名字
printf("%s",week_name_en[0]);
for(j=1;j<7;j++)
{
printf("%4s",week_name_en[j]);
}
for(j=0;j<4;j++)
printf(" ");
printf("%s",week_name_en[0]);
for(j=1;j<7;j++)
{
printf("%4s",week_name_en[j]);
}
printf("\n");
//星期的英文名字输出完毕
//开始输出当前月的日期
//一行一行的输出，同时输出两个月的
//每个月的日期是一个6*7的方形矩阵

//先输出第一个行，

if(i!=0){
gday2=gday1+max_day1;
}
else
gday2=1+max_day1;
//输出站位空字符
for(w=0;w<wday1;w++)
{
if(w==0)
printf("%3s"," ");
else
printf("%4s"," ");
}
//输出日期
for(;w<7;w++)
{
if(w==0){
printf("%3d",fmt?gday1:day1);
}
else{
printf("%4d",fmt?gday1:day1);
}
day1++;
gday1++;
}
//第一个月的第一行输出完毕
//输出4个空格作为间隔
printf("%4s"," ");
//输出第二个月的第一行
//此处应该可以根据上一个月算出从第几个开始

//输出站位空字符
for(w=0;w<wday2;w++)
{
if(w==0)
printf("%3s"," ");
else
printf("%4s"," ");
}
//输出日期

for(;w<7;w++)
{
if(w==0){
printf("%3d",fmt?gday2:day2);
}
else{
printf("%4d",fmt?gday2:day2);
}
day2++;
gday2++;
}
printf("\n");
//开始下面的输出
for(j=1;j<6;j++)
{
//第一个矩阵
//开始输出日期
for(w=0;w<7;w++)
{
if(day1<=max_day1)
{
if(w==0){
printf("%3d",fmt?gday1:day1);
}
else{
printf("%4d",fmt?gday1:day1);
}
day1++;
gday1++;
}else{
if(w==0)
printf("%3s"," ");
else
printf("%4s"," ");
}
}
printf("%4s"," ");

//第二个矩阵
//gday2=gday1+max_day1;
for(w=0;w<7;w++)
{
if(day2<=max_day2)
{
if(w==0)
printf("%3d",fmt?gday2:day2);
else
printf("%4d",fmt?gday2:day2);
day2++;
gday2++;
}else{

if(w==0)
printf("%3s"," ");
else
printf("%4s"," ");
}
}
printf("\n");
}
gday1=gday2;
wday1=(max_day1-(7-wday2)) % 7;
}
printf("\n");
}

void printMonthOnYearCal(PDate date,int fmt){
int i;
int m_len;
int day;
int max_day;
int p=1;
max_day=monthMaxDay(date->tm_year,date->tm_mon);
printf("%*s %d %s\n",(27-(m_len=strlen(month_name_en[date->tm_mon])))/2+m_len-4,month_name_en[date->tm_mon],date->tm_year+1900,animals[((date->tm_year+1900)-4)%12]);
printf(week_name_en[0]);
for(i=1;i<7;i++)
{
printf("%*s",4,week_name_en[i]);
}
printf("\n");
for(i=0;i<date->tm_wday;i++)
{
if(i==0)
printf("%*s",3," ");
else
printf("%*s",4," ");
}
day=1;
if(fmt==1)
day=date->tm_yday+1;
for(;i<7;i++){
if(i==0)
printf("%*d",3,day++);
else
printf("%*d",4,day++);
if(i==6){
i=-1;
printf("\n");
}
if(p++>=max_day)
break;
}
printf("\n");

}
int main(int argc,char *argv[]){
int y;
int m;
int fmt;
fmt=0;
y=-1;
m=-1;
time_t c_tm;
time_t c_tm2;

PDate pdate;
PDate pdate2;
int i;
for(i=1;i<argc;)
{
if(!strcmp(argv[i],"-m")&&(i+1<argc))
{
m=atoi(argv[i+1])-1;
if(m<0||m>11)
{
printf("month range (1~12)\n");
printf("-h help info.\n");
exit(0);
return 0;
}
i+=2;
}
else if(!strcmp(argv[i],"-y") && (i+1<argc)){
y = atoi(argv[i+1])-1900;
if(y<=0)
{
printf("year range (>1900)\n");
printf("-h help info.\n");
exit(0);
return 0;
}
i+=2;
}else if(!strcmp(argv[i],"-j"))
{
i++;
fmt=1;
}else if(!strcmp(argv[i],"-h"))
{
printHelp();
exit(0);
return 0;
}else {
printHelp();
exit(0);
return 0;
}
}
time(&c_tm);
pdate=localtime(&c_tm);
if(m==-1)
{
if(y>0)
{
pdate->tm_year=y;
printYearCal(pdate,fmt);
}else{
printMonthOnYearCal(pdate,fmt);
}
}else{
if(y>0)
{
pdate->tm_year=y;
pdate->tm_mon=m;
pdate->tm_mday=1;
c_tm2=mktime(pdate);
if(c_tm2==-1)
{
printf("can't mktime . \n");
printf("-h help info.\n");
exit(0);
return 0;
}
pdate2=localtime(&c_tm2);
printMonthOnYearCal(pdate2,fmt);
}else{
printMonthOnYearCal(pdate,fmt);
}
}
return 0;
}

/*****************************************
* FILE : hashtable.h
* DATE : 2008/01/06
* AUTHOR : ZhangLiHai
* ***************************************/
#ifndef HASHTABLE_H_
#define HASHTABLE_H_
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
typedef struct __hash_entry hash_entry;
typedef struct __hash_entry* p_hash_entry;
typedef struct __hash_table hashtable;
typedef struct __hash_table* p_hashtable;

typedef int BOOL;
#define TRUE 1
#define FALSE 0
struct __hash_entry{
p_hash_entry next;//next entry
unsigned int hash_code;//key hash_code...
const char* key; //key..
const void* value;//value object
int klen; //entry size.
};
struct __hash_table{
int capacity;// array length.
int size;//cur size
unsigned int (*hash_code_fp)(const char*);//hash_code function pointer.
void (*value_free_fp)(void*);
void (*key_free_fp)(char*);
p_hash_entry *array; //entry array;
};

//foreach function pointer.
typedef BOOL (*hash_foreach_fp)(p_hash_entry);

/***********************
*
* 创建一个hashtable指针
*
* *********************/
p_hashtable new_hashtab();

p_hash_entry new_entry();

/***************************************
*
* 将key,value放入hash结构里面
*
* *************************************/
BOOL hash_put(p_hashtable,const char*, const void*);


/******************************************
*
*
* 根据key返回一个void *
*
*
* ******************************************/
void* hash_get(p_hashtable,const char*);

/*****************************************
*
* 重新分配hash空间
*
* 重新规划元素的位置
* ***************************************/
BOOL hash_resize(p_hashtable );



/****************************************
*
*
* hash code算法的默认实现~
*
*
* **************************************/
unsigned int hash_code_fp_default(const char*);


/**************
*
*
* 删除某个key下的值
*
*
*
* **********************/
BOOL hash_remove_key(p_hashtable, const char*);

/********************
*
* 清除hash里面的所有数据，但是保存hashtable本身
*
* **********************/
BOOL hash_data_clear(p_hashtable );


/*****************
*
* 看某个key是否在hash里面
*
* ************************/
BOOL hash_contains_key(p_hashtable, const char*);
/**************************
* 迭代函数
* 一个是清楚数据，另一个没有清除
* ******************/
void hash_foreach_no_clear(p_hashtable,hash_foreach_fp);
void hash_foreach_clear(p_hashtable,hash_foreach_fp);
/********************************
*
* 两个默认的free方法，调用stdlib的free函数
*
* *******************************/
void std_key_free(char *);
void std_value_free(void *);

/************************
*
* 回收一个hashtable指针
*
* 如果里面的value需要回收，则传入一个函数指针
*
* ************************/
BOOL free_hashtab(p_hashtable );

#endif /*HASHTABLE_H_*/

/*****************************************
* FILE : hashtable.c
* DATE : 2008/01/06
* AUTHOR : ZhangLiHai
* ***************************************/
#include "hashtable.h"

#define MAX_SIZE 1024
#define HASH_IND(h,n) ((h)%(n))

p_hashtable new_hashtab(){
p_hashtable tab;
tab = (p_hashtable)malloc(sizeof(struct __hash_table));
printf("new hashtable \n");
tab->size=0;
tab->capacity=MAX_SIZE;
tab->array=(p_hash_entry*)calloc(tab->capacity,sizeof(p_hash_entry));
printf("new hashtable->array pointer. \n");
tab->hash_code_fp=&hash_code_fp_default;
tab->value_free_fp=NULL;
tab->key_free_fp=NULL;
return tab;
}

p_hash_entry new_entry(){
p_hash_entry this;
this = (p_hash_entry)malloc(sizeof(struct __hash_entry));
this->hash_code=0;
this->key=NULL;
this->klen=0;
this->next=NULL;
this->value=NULL;
printf("new entry . \n");
return this;
}
unsigned int hash_code_fp_default(const char* key){
register unsigned int hash;
for(hash=0;*key;key++)
hash = *key+hash*31;
return abs(hash);
}

void std_key_free(char *p){
if(p)
free(p);
}

void std_value_free(void *p){
if(p)
free(p);
}


BOOL hash_remove_key(p_hashtable tab, const char* key)
{
void* value;
p_hash_entry e,prev,next;
int hash,ind;
if(!tab||!key)return FALSE;
hash=tab->hash_code_fp(key);
ind=HASH_IND(hash,tab->capacity);
e=tab->array[ind];
prev=e;
next=NULL;
while(e)
{
next=e->next;
if(e->hash_code==hash && !strcmp(key,e->key))
{
tab->size--;
if(e==prev)
tab->array[ind]=next;
else
prev->next=next;
break;
}else{
prev=e;
e=next;
}
}
if(e){
if(tab->key_free_fp)tab->key_free_fp((char *)e->key);
if(tab->value_free_fp)tab->value_free_fp((void *)e->value);
free(e);
printf("free entry\n");
return TRUE;
}
return FALSE;
}

BOOL hash_data_clear(p_hashtable tab)
{
p_hash_entry p;
p_hash_entry q;
int i=0;
if(!tab)return FALSE;
for(i=0;i<tab->capacity;i++)
{
for(p=tab->array[i];p;p=q)
{
q=p->next;
if(tab->key_free_fp)tab->key_free_fp((char*)p->key);
if(tab->value_free_fp)tab->value_free_fp((void*)p->value);
free(p);
printf("free hash entry \n");
}
tab->array[i]=0;
}
tab->size=0;
return TRUE;
}

BOOL free_hashtab(p_hashtable tab)
{
hash_data_clear(tab);
free(tab->array);
printf("free--hash->array.\n");
tab->array=NULL;
tab->capacity=0;
free(tab);
printf("free--hashtab.\n");
tab=NULL;
return TRUE;
}

void* hash_get(tab,key)
p_hashtable tab;
const char* key;
{
p_hash_entry e;
int hash;
if(!tab||!key)return NULL;
hash=tab->hash_code_fp(key);
for(e=tab->array[HASH_IND(hash,tab->capacity)];e;e=e->next)
{
if(e->hash_code==hash&&!strcmp(e->key,key))
{
return ((void *)e->value);
}
}
return NULL;
}

BOOL hash_put(p_hashtable tab,const char* key, const void* value){
int hash ;
int ind;
p_hash_entry next_entry;
p_hash_entry entry;
if(!tab||!key||!value)return FALSE;
hash = tab->hash_code_fp(key);
ind = HASH_IND(hash,tab->capacity);
next_entry=tab->array[ind];
entry=new_entry();
entry->hash_code=hash;
entry->key=key;
entry->value=value;
entry->next=next_entry;
entry->klen=strlen(key);
tab->array[ind]=entry;
tab->size++;
if((tab->size*3/2)>tab->capacity)
hash_resize(tab);
return TRUE;
}

BOOL hash_resize(p_hashtable tab){
p_hash_entry* new_array;
p_hash_entry entry,next;
int new_capacity,i,ind;
new_capacity=tab->capacity*2;
new_array=(p_hash_entry*)calloc(new_capacity,sizeof(p_hash_entry));
for(i=0;i<tab->capacity;i++){
if(entry=tab->array[i]){
do{
tab->array[i]=0;
next = entry->next;
ind=HASH_IND(entry->hash_code,new_capacity);
entry->next=new_array[ind];
new_array[ind]=entry;
entry=next;
}while(entry);
}
}
free(tab->array);
printf("resize free old array \n");
printf("hash_resize to %d\n",new_capacity);
tab->array=new_array;
tab->capacity=new_capacity;
return TRUE;
}

BOOL hash_contains_key(p_hashtable tab, const char* key){
if(!tab||!key)return FALSE;
return (hash_get(tab,key)!=NULL);
}


void hash_foreach_no_clear(p_hashtable tab,hash_foreach_fp fp){
int i;
if(!tab||!fp)return;
for(i=0;i<tab->capacity;i++)
{
if(tab->array[i])
if(!fp(tab->array[i]))
return;
}
}
void hash_foreach_clear(p_hashtable tab,hash_foreach_fp fp)
{
p_hash_entry p;
p_hash_entry q;
int i=0;
if(!tab||!fp)return;
for(i=0;i<tab->capacity;i++)
{
for(p=tab->array[i];p;p=q)
{
q=p->next;
fp(p);
if(tab->key_free_fp)tab->key_free_fp((char*)p->key);
if(tab->value_free_fp)tab->value_free_fp((void*)p->value);
free(p);
printf("free hash entry \n");
}
tab->array[i]=0;
}
tab->size=0;
}

unsigned int hash_code_fp_simple(const char* key){
return 101;
}

BOOL hash_foreach_fp_simple(p_hash_entry e){
printf("foreach : key=%s,value=%s\n",e->key,e->value);
return TRUE;
}
int main(){
int i;
char *key,*value;
char key_buf[11];
p_hashtable tab = new_hashtab();
tab->key_free_fp=&std_key_free;
tab->value_free_fp=&std_value_free;
tab->hash_code_fp=&hash_code_fp_default;
for(i=0;i<100;i++)
{
key=(char *)malloc(sizeof(char)*11);
value=(char *)malloc(sizeof(char)*11);
memset(key,0,11);
memset(value,0,11);
sprintf(key,"key_%d",i);
sprintf(value,"val_%d",i);
hash_put(tab,key,value);
}
hash_foreach_no_clear(tab,&hash_foreach_fp_simple);
hash_remove_key(tab,"key_2");
for(i=10;i<tab->size;i++)
{
memset(key_buf,0,11);
sprintf(key_buf,"key_%d",i);
printf("get==>key=%s,val=%s\n",key_buf,hash_get(tab,key_buf));
}
hash_data_clear(tab);
printf("hash.size : %d\n",tab->size);
free_hashtab(tab);
return 0;
}