开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
string.c
资源名称：tizos.rar　[点击查看]
上传用户：qddsws
上传日期：2022-06-22
资源大小：723k
文件大小：7k
源码类别：

操作系统开发

开发平台：

C/C++

string.c：源码内容
  1. #include <lib/string.h>
  2. //unsigned char *VGA = (unsigned char *)0xA0000;
  4. int cursorx,cursory;
  5. #include <Bitmapfonts/font1.fnt>
  6. #include <Bitmapfonts/font2.fnt>
  7. #include <Bitmapfonts/font4.fnt>
  8. #include <Bitmapfonts/font5.fnt>
  10. int act;
  12. char *itoa (unsigned long number,char* ret, int base) {
  13. int count=0;
  14. int k=0;
  15. int res=0;
  16. if (number==0) {
  17. ret[0]='0';
  18. ret[1]='';
  19. }
  20. else {
  21. while (number!=0) {
  22. res=number%base;
  23. number=number/base;
  24. if (res<10) ret[k]=res+'0';
  25. else ret[k]=(res-10)+'a';
  26. k++;
  27. }
  28. count=k;
  29. k--;
  30. for(res=0;res < k;res++,k--) {
  31. ret[res]^=ret[k];  
  32. ret[k]^=ret[res];  
  33. ret[res]^=ret[k];
  34. }
  35. }
  36. //if (number==0) {
  37. // ret[0]='0';
  38. // count=1;
  39. //}
  41. ret[count]=0;
  42. return ret;
  43. }
  45. void snprintf (char* dest,const char *fmt, ...){
  46. const char *p;
  47. va_list argp;
  48. int i;
  49. char *s;
  50. char fmtbuf[256];
  51. int k=0;
  53. va_start(argp, fmt);
  55. for(p = fmt; *p != ''; p++){
  56. if(*p != '%') {
  57. //putchar(*p);
  58. dest[k]=*p;
  59. k++;
  60. continue;
  62. }
  64. switch(*++p) {
  65. case 'c':
  66. i = va_arg(argp, int);
  67. dest[k]=i;
  68. k++;
  69. //putchar(i);
  70. break;
  72. case 'd':
  73. i = va_arg(argp, int);
  74. s = itoa(i,fmtbuf,10);
  75. strcpy(&dest[k],s);
  76. k=k+strlen(s);
  77. //fputs(s, stdout);
  78. break;
  80. case 's':
  81. s = va_arg(argp, char *);
  82. strcpy(&dest[k],s);
  83. k=k+strlen(s);
  84. //fputs(s, stdout);
  85. break;
  87. case 'x':
  88. i = va_arg(argp, int);
  89. s = itoa(i, fmtbuf, 16);
  90. strcpy(&dest[k],s);
  91. k=k+strlen(s);
  92. //fputs(s, stdout);
  93. break;
  96. case '%':
  97. //putchar('%');
  98. dest[k]='%';
  99. k++;
  101. break;
  102. }
  103. }
  104. dest[k]='';
  105. va_end(argp);
  106. }
  111. void jump_to_line (int l) {
  113. cursorx=0;
  114. cursory=l;
  115. }
  117. /*char* itoa(int number) {
  118.   char *ret;
  119.   
  120.           char num[5];
  121.           char mun[5];
  122.   ret=(char*)&num;
  123.   int sign=1;
  124.           int x,y;
  125.           for (x=0;x<5;x++) num[x]=0;
  126.           for (x=0;x<5;x++) mun[x]=0;
  127.   if (number<0) {
  128.      number=number*-1;
  129. sign=-1;
  130.   }
  131.   num[0]='0';
  132.           x=0;
  133.           y=number;
  134.           while (y>0) {
  135.               mun[x]=y%10+'0';
  136.               x++;
  137.               y=y/10;
  138.   }
  139.   y=0;
  140.   if (sign==-1) {
  141.      num[0]='-';
  142. y++;
  143.   }
  144.   while (x>0) {
  145.      num[y]=mun[x-1];
  146. y++;
  147. x--;
  148.   }
  150.           return ret;
  151. }
  154. */
  160. void hexkprint4b(unsigned long num) {
  161. char *aux;
  162. char hexnum[5];
  163. hexnum[4]=0;
  164. unsigned long auxtmp=num;/*
  165. if ((auxtmp&0xF)>9) hexnum[3]='A'+(auxtmp&0xF)-10;
  166. else {
  167. aux = itoa (auxtmp&0xF);
  168. hexnum[3]=aux[0];
  169. }
  170. if (((auxtmp&0xF0)>>4)>9) hexnum[2]='A'+((auxtmp&0xF0)>>4)-10;
  171. else {
  172. aux = itoa ((auxtmp&0xF0)>>4);
  173. hexnum[2]=aux[0];
  174. }
  175. if (((auxtmp&0xF00)>>8)>9) hexnum[1]='A'+((auxtmp&0xF00)>>8)-10;
  176. else {
  177. aux = itoa ((auxtmp&0xF00)>>8);
  178. hexnum[1]=aux[0];
  179. }
  180. if (((auxtmp&0xF000)>>12)>9) hexnum[0]='A'+((auxtmp&0xF000)>>12)-10;
  181. else {
  182. aux = itoa ((auxtmp&0xF000)>>12);
  183. hexnum[0]=aux[0];
  184. }*/
  186.  kprint(hexnum);
  190. }
  192. void hexkprint8b(unsigned long num) {
  193. hexkprint4b(num>>16&0xFFFF);
  194. hexkprint4b(num&0xFFFF);
  195. }
  197. void clrscr() {
  199. cursorx=0;
  200. cursory=0;
  201. if (act==1) memset(VGA,BACKGROUND_COLOR,SWIDTH*SHEIGHT*BPP);
  202. }
  204. void test_printk( char * str) {
  206.   int i=0;
  207.   while (str[i]!=0 && i < SWIDTH/(FONT_W)) {
  208.      switch (str[i]) {
  210. case 'n':
  211.      str[i]='';
  212. xyprint(str,cursorx*FONT_W,cursory*FONT_H,DEF_COLOR,DEF_FONT);
  213. cursorx=0;
  214. cursory=cursory+1;
  215. str=str+i+1 ;
  216. i=-1;
  217.   
  218. break;
  219. }
  220. i++;
  222.   }
  223.   
  224.   xyprint(str,cursorx*FONT_W,cursory*FONT_H,DEF_COLOR,DEF_FONT);
  225. cursorx=cursorx+strlen(str);
  226.  
  227. }
  228. #include <devices/sys_console.h>
  229. void kprint( char * str ) {
  232. if (act==2) {
  233. // sys_console_print_text(test_ret_print(),"*");
  234. sys_console_print_text(test_ret_print(),str);
  235. }
  236. else {
  237. int i=0;
  238. while (str[i]!='' && (i+cursorx) < SWIDTH/(FONT_W)) {
  239. switch (str[i]) {
  241. case 'n':
  242.      str[i]='';
  243. xyprint(str,cursorx*FONT_W,cursory*FONT_H,DEF_COLOR,DEF_FONT);
  244. cursorx=0;
  245. cursory=cursory+1;
  246. str=str+i+1 ;
  247. i=-1;
  248.   
  249. break;
  250. }
  251. i++;
  252. if (i+cursorx ==  SWIDTH/(FONT_W) ) {
  253. str[i]='';
  254. xyprint(str,cursorx*FONT_W,cursory*FONT_H,DEF_COLOR,DEF_FONT);
  255. cursorx=0;
  256. cursory=cursory+1;
  257. str=str+i+1 ;
  258. i=0;
  260.  
  261. }
  263. }
  264.   
  265.   xyprint(str,cursorx*FONT_W,cursory*FONT_H,DEF_COLOR,DEF_FONT);
  266. cursorx=cursorx+strlen(str);
  267. }
  268. }
  269. void deact_print () {
  270. act=0;
  271. }
  273. void act_print (int i) {
  274. act=i;
  275. }
  277. void xyprint_area( char * str, int x, int y, int color, int font, word* temp_area) {
  278.   int i=0;
  279. int j=0;
  280. int k=0;
  281. word lin[FONT_W-1];
  282. word lin_mask[FONT_W-1];
  283. word lin_notmask[FONT_W-1];
  284. char faux1;
  286. for (k=0;k<strlen(str);k++) {
  287. int lletra=str[k];
  288. for (j=0;j<FONT_H;j++) {
  289. for (i=0;i<FONT_W;i++) {
  290.    #ifdef FONT1
  291.    if (font==1) faux1=font1[j+(lletra*(FONT_H))];
  292. #endif
  293. #ifdef FONT2
  294. if (font==2) faux1=font2[j+(lletra*(FONT_H))];
  295. #endif
  296. #ifdef FONT4
  297. if (font==4) faux1=font4[j+(lletra*(FONT_H))];
  298. #endif
  299. #ifdef FONT5
  300. if (font==5) faux1=font5[j+(lletra*(FONT_H))];
  301. #endif
  303.     faux1 = faux1 >> i;
  304.     faux1=faux1 & 0x01;
  305.     if (faux1==0x01) {
  306.       lin[FONT_W-1-i]=color;
  307.     }
  308. else{ 
  309.     lin[FONT_W-1-i]=*(word*)(temp_area+(SWIDTH*(y+j))+(x+(FONT_W-1-i)+((FONT_W)*k)));
  310. }
  311.   }
  313.    memcpy (temp_area+(SWIDTH*(y+j))+(x+((FONT_W)*k)),&lin,FONT_W*2);
  314. }
  315. }
  316. }
  318. void xyprint( char * str, int x, int y, int color, int font) {
  319.   int i=0;
  320. int j=0;
  321. int k=0;
  322. word lin[FONT_W-1];
  323. word lin_mask[FONT_W-1];
  324. word lin_notmask[FONT_W-1];
  325. char faux1;
  327. for (k=0;k<strlen(str);k++) {
  328. int lletra=str[k];
  329. for (j=0;j<FONT_H;j++) {
  330. for (i=0;i<FONT_W;i++) {
  331.    #ifdef FONT1
  332.    if (font==1) faux1=font1[j+(lletra*(FONT_H))];
  333. #endif
  334. #ifdef FONT2
  335. if (font==2) faux1=font2[j+(lletra*(FONT_H))];
  336. #endif
  337. #ifdef FONT4
  338. if (font==4) faux1=font4[j+(lletra*(FONT_H))];
  339. #endif
  340. #ifdef FONT5
  341. if (font==5) faux1=font5[j+(lletra*(FONT_H))];
  342. #endif
  344.     faux1 = faux1 >> i;
  345.     faux1=faux1 & 0x01;
  346.     if (faux1==0x01) {
  347.       lin[FONT_W-1-i]=color;
  348.     }
  349. else{ 
  350.     lin[FONT_W-1-i]=*(word*)(VGA+(SWIDTH*(y+j))+(x+(FONT_W-1-i)+((FONT_W)*k)));
  351. }
  352.   }
  354.    memcpy (VGA+(SWIDTH*(y+j))+(x+((FONT_W)*k)),&lin,FONT_W*2);
  355. }
  356. }
  357. }
  359. int abs(int num ) {
  360. if (num<0) num=-num;
  361. return num;
  362. }
  364. void* memwordset(void* dest, word c, dword count) {
  365.   word *ds=dest;
  366. dword i;
  367. for (i=0;i<count;i++) 
  368. ds[i]=c;
  370. return dest;
  372. }
  374. void* memset(void* dest, int c, unsigned int count)
  375. {
  376.      unsigned char* ds = dest;
  378.      unsigned int i;
  379.   for (i = 0; i < count; i++)
  380.            ds[i] = c;
  382.       return dest;
  383. }
  388. void* memcpy(void* dest, const void* src, unsigned int count)
  389. {
  390.    unsigned char* ds = (unsigned char*)dest;
  391.    unsigned char* ss = (unsigned char*)src;
  392.    unsigned int i;
  393.    for (i = 0; i < count; i++)
  394.       ds[i] = ss[i];
  395.         return dest;
  396. }
  398. unsigned int strlen(const char* str)
  399. {
  400.    const char *s;
  402.    for (s = str; *s; ++s) ;
  403.    return (s - str);
  404. } 
  406. char * strcpy(char * dest,const char *src)
  407. {
  408. char *tmp = dest;
  409.         while ((*dest++ = *src++) != '');
  410.         return tmp;
  411. }
  413. int strcmp(const char * cs,const char * ct)
  414. {
  415. register signed char __res;
  416.         while (1) {
  417.          if ((__res = *cs - *ct++) != 0 || !*cs++) break;
  418. }
  419.        
  420. return __res;
  421. }
  422. int strncmp(const char * cs,const char * ct, int n)
  423. {
  425. register signed char __res;
  426.         while (n>0) {
  427.          if ((__res = *cs - *ct++) != 0 || !*cs++) break;
  428. n--;
  429. }
  430.        
  431. return __res;
  432. }