kernel/DivergeAPI.c

   1 /*
   2         DivergeAPI.c
   3         Diverge API
   4         (C) 2014-2015 VOSystems.
   5 */
   6
   7 #include<Diverge/diverge.h>
   8 #include<Diverge/types.h>
   9
  10 void InitCharArrey(char* arrey,size_t lengh)
  11 {
  12         unsigned int i;
  13         for(i=0;i<lengh;i++)*arrey++ =0;
  14         return;
  15 }
  16
  17 void Sleep(unsigned long milisec)
  18 {
  19         unsigned long sec;
  20         for(sec=0;sec<=milisec;sec+=10)io_hlt();
  21 }
  22
  23 char GetKeyBoardChar(void)
  24 {
  25         Generate_Scancode_To_ASCII_Code();
  26 }
  27
  28 int CharCountInStr(char* str, char cha)
  29 {
  30         int C,count=0;
  31         for(C=0; str[C]!='\0'; C++){
  32                 if(str[C]==cha)count++;
  33         }
  34         return count;
  35 }
  36
  37 void StringConnect(char* dest, const char* src)
  38 {
  39         size_t dest_len=strlen(dest);
  40         size_t C;
  41
  42         for(C=0; src[C]!='\0'; dest_len++, C++){
  43                 dest[dest_len]=src[C];
  44         }
  45 }
  46
  47 void StringBreak(char* dest, const char separate)
  48 {
  49         size_t len=strlen(dest);
  50
  51         while(dest[len]!=separate){
  52                 dest[len]='\0';
  53                 len--;
  54         }
  55         dest[len]='\0';
  56 }
  57
  58 int StringCompare(const char* s1, const char* s2, const char separate)
  59 {
  60         while(*s1==*s2) {
  61                 if(*s1=='\0')return 0;
  62                 s1++;
  63                 s2++;
  64                 if(*s1==separate || *s2==separate)return 0;
  65         }
  66         return ((unsigned char)*s1 - (unsigned char)*s2);
  67 }
  68
  69 void LoadingPromptSec(unsigned int Sec)
  70 {
  71         int C;
  72         for(C=0; C<((Sec*1000)/(100*4)); C++){
  73                 LoadingPrompt();
  74         }
  75 }
  76
  77 void LoadingPrompt(void)
  78 {
  79         kputchar('/');
  80         Sleep(100);
  81         kputchar('\b');
  82         kputchar('-');
  83         Sleep(100);
  84         kputchar('\b');
  85         kputchar('\\');
  86         Sleep(100);
  87         kputchar('\b');
  88         kputchar('|');
  89         Sleep(100);
  90         kputchar('\b');
  91 }
  92
  93 static void memswap(void *x, void *y, size_t n)
  94 {
  95         unsigned char *a=(unsigned char*)x;
  96         unsigned char *b=(unsigned char*)y;
  97
  98         for(; n--; a++, b++){
  99                 unsigned char c=*a;
 100                 *a=*b;
 101                 *b=c;
 102         }
 103 }
 104
 105 void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *))
 106 {
 107         if(nmemb>0){
 108                 size_t pl=0;//左カーソル */
 109                 size_t pr=nmemb-1;//右カーソル
 110                 size_t pv=nmemb;//ピボット
 111                 size_t pt=(pl + pr)/2;//ピボットの更新値
 112                 char *v=(char *)base;//先頭要素へのポインタ
 113                 char *x;//ピボットへのポインタ
 114
 115                 do{
 116                         if (pv != pt) x = &v[(pv = pt) * size];
 117
 118                         while (compar((const void *)&v[pl * size], x) < 0) pl++;
 119                         while (compar((const void *)&v[pr * size], x) > 0) pr--;
 120                         if (pl <= pr) {
 121                                 pt = (pl == pv) ? pr : (pr == pv) ? pl : pv;
 122                                 memswap(&v[pl * size], &v[pr * size], size);
 123                                 pl++;
 124                                 if (pr == 0)    /* 符号無し整数0からのデクリメントを避ける */
 125                                 goto QuickRight;
 126                                 pr--;
 127                         }
 128                 }while(pl<=pr);
 129
 130                 if(0<pr)qsort(&v[0], pr+1, size, compar);
 131 QuickRight:
 132                 if(pl<nmemb-1)qsort(&v[pl*size], nmemb-pl, size, compar);
 133         }
 134 }
 135
 136 char* ScanPassword(char* buf)
 137 {
 138         char *p=buf;
 139         char tmp=0;
 140         unsigned int count=0;
 141
 142         while(1){
 143                 tmp=kgetch();
 144                 if(tmp==' ' || tmp=='\n'){
 145                         kputchar('\n');
 146                         *p='\0';
 147                         break;
 148
 149                 }else if(tmp=='\b' && count>0){
 150                         *p-- ='\0';
 151                         count--;
 152                         kputchar('\b');
 153                 }else{
 154                         if(tmp!='\b'){
 155                                 *p++ =tmp;
 156                                 count++;
 157                                 kputchar('*');
 158                         }else{
 159                                 if(count>0){
 160                                         *p-- ='\0';
 161                                         count--;
 162                                         kputchar('\b');
 163                                 }
 164                         }
 165                 }
 166                 if(count+1 > 256){
 167                         kputchar('\n');
 168                         *p='\0';
 169                         break;
 170
 171                 }
 172         }
 173         return buf;
 174 }
 175
 176 /* a/b = ans ... rem*/
 177 static int Divide16on32(unsigned int a, unsigned int b, unsigned int* ans, unsigned int* rem)
 178 {
 179         if(b==0)return -1;
 180         *ans=a/b;
 181         *rem=a%b;
 182         return 0;
 183 }
 184
 185 unsigned long long DivideU64(unsigned long long a, unsigned int b)
 186 {
 187         unsigned int a1, a2, a3, a4;
 188         unsigned int b1, b2, b3, b4;
 189         unsigned long long ans;
 190
 191         a1=a>>48;
 192
 193         a2=(a1<<16)^(a>>32);
 194
 195         a3=((a1<<32)|(a2<<16))^(a>>16);
 196
 197         a4=((a1<<48)|(a2<<32)|(a3<<16))^a;
 198
 199         unsigned int ans1,rem1;
 200         if(Divide16on32(a1,b,&ans1,&rem1)==-1)return 0;
 201         a2 |= rem1<<17;
 202
 203         unsigned int ans2,rem2;
 204         if(Divide16on32(a2,b,&ans2,&rem2)==-1)return 0;
 205         a3 |= rem2<<17;
 206
 207         unsigned int ans3,rem3;
 208         if(Divide16on32(a3,b,&ans3,&rem3)==-1)return 0;
 209         a4 |= rem3<<17;
 210
 211         unsigned int ans4,rem4;
 212         if(Divide16on32(a4,b,&ans4,&rem4)==-1)return 0;
 213
 214         ans=(ans1<<48)+(ans2<<32)+(ans3<<16)+ans4;
 215
 216         return ans;
 217 }
 218
 219 int hex2dec_bcd(int hex)
 220 {
 221         int i,m,n=0;
 222         m=hex/16;
 223         if(0x0<=m && m<=0x9){
 224                 n+=m*10;
 225
 226         }else{
 227                 n+=0;
 228
 229         }
 230         m=hex-(m*16);
 231         if(0x0<=m && m<=0x9){
 232                 n+=m;
 233
 234         }else{
 235                 n+=0;
 236
 237         }
 238         return n;
 239 }
 240
 241 unsigned int DivideU64_2(unsigned long long a, unsigned long long b)
 242 {
 243         int i;
 244         unsigned long long i_a = 0;
 245         unsigned long long i_b = 0;
 246         unsigned long long i_op1 = (unsigned long long)a;
 247         unsigned long long i_op2 = (unsigned long long)b << 32;
 248         for(i=1; i<=64; i++){
 249                 i_a <<= 1;
 250                 i_op1 <<= 1;
 251                 i_b = i_op1 - i_op2;
 252                 if( i_b >= 0 ){
 253                         i_a |= 0x01;
 254                         i_op1 = i_b;
 255                 }
 256         }
 257         unsigned int ans = i_a >> 16;
 258
 259         return ans;
 260 }