Subversion Repositories Kolibri OS

Rev

Rev 3247 | Rev 4050 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1.  
  2. /// ===========================================================
  3.  
  4. void command_history_add(char command[])
  5. {
  6.  
  7. if (    (0 != strcmp( CMD_HISTORY[0], CMD)) &&
  8.         (0 != strcmp( CMD_HISTORY[1], CMD)) &&
  9.         (0 != strcmp( CMD_HISTORY[2], CMD)) &&
  10.         (0 != strcmp( CMD_HISTORY[3], CMD)) &&
  11.         (0 != strcmp( CMD_HISTORY[4], CMD)) &&
  12.         (0 != strcmp( CMD_HISTORY[5], CMD)) &&
  13.         (0 != strcmp( CMD_HISTORY[6], CMD)) &&
  14.         (0 != strcmp( CMD_HISTORY[7], CMD)) &&
  15.         (0 != strcmp( CMD_HISTORY[8], CMD)) &&
  16.         (0 != strcmp( CMD_HISTORY[9], CMD)) )
  17.  
  18.         {
  19.         strcpy(CMD_HISTORY[9], CMD_HISTORY[8]);
  20.         strcpy(CMD_HISTORY[8], CMD_HISTORY[7]);
  21.         strcpy(CMD_HISTORY[7], CMD_HISTORY[6]);
  22.         strcpy(CMD_HISTORY[6], CMD_HISTORY[5]);
  23.         strcpy(CMD_HISTORY[5], CMD_HISTORY[4]);
  24.         strcpy(CMD_HISTORY[4], CMD_HISTORY[3]);
  25.         strcpy(CMD_HISTORY[3], CMD_HISTORY[2]);
  26.         strcpy(CMD_HISTORY[2], CMD_HISTORY[1]);
  27.         strcpy(CMD_HISTORY[1], CMD_HISTORY[0]);
  28.  
  29.         strcpy(CMD_HISTORY[0], CMD);
  30.        
  31.         if (CMD_HISTORY_NUM_REAL < CMD_HISTORY_NUM)
  32.                 CMD_HISTORY_NUM_REAL++;
  33.        
  34.         }
  35.  
  36. }
  37.  
  38. /// ===========================================================
  39.  
  40. void command_get()
  41. {
  42. unsigned key;
  43.  
  44. unsigned i;
  45. unsigned cmdLen = 0;
  46. unsigned cmdPos = 0;
  47. CMD[0] = '\0';
  48.  
  49. for (;;)
  50.         {
  51.         key = getch();
  52.         if ( 0 != (key & 0xff) )
  53.                 {
  54.                 key &= 0xff;
  55.                 switch (key)
  56.                         {
  57.                         case 27: // ESC
  58.                                 for (i = cmdPos; i < cmdLen; i++)
  59.                                     printf(" ");
  60.                                 for (i = cmdLen; i > 0; i--)
  61.                                     printf("%c %c", 8, 8);
  62.                                 cmdLen = 0;
  63.                                 cmdPos = 0;
  64.                                 CMD[0] = '\0';
  65.                                 break;
  66.  
  67.  
  68.                         case 13: // ENTER
  69.                                 printf("\n\r");
  70.                                 command_history_add(CMD);
  71.                                 return;
  72.  
  73.  
  74.                         case 8: // BACKSPACE
  75.                                 if (cmdPos > 0)
  76.                                         {
  77.                                         for (i = cmdPos-1; i < cmdLen; i++)
  78.                                             CMD[i] = CMD[i+1];
  79.  
  80.                                         for (i = 0; i < cmdLen-cmdPos; i++)
  81.                                             printf (" ");
  82.  
  83.                                         for (i = 0; i < cmdLen; i++)
  84.                                             printf ("%c %c", 8, 8);
  85.  
  86.                                         printf("%s", CMD);
  87.  
  88.                                         for (i = 0; i < cmdLen-cmdPos; i++)
  89.                                             printf("%c", 8);
  90.  
  91.                                         cmdPos--;
  92.                                         cmdLen--;
  93.                                         }
  94.                                 break;
  95.  
  96.  
  97.                         case 9: // TAB
  98.                                 break;
  99.  
  100.  
  101.                         default:
  102.                                 if (cmdLen < 255)
  103.                                         {
  104.                                         if ( kol_key_control() & 0x40 ) // ¥á«¨ ¢ª«îçñ­ CapsLock
  105.                                                 if ( (kol_key_control() & 1) || (kol_key_control() & 2)) // ¥á«¨ ­ ¦ âë è¨äâë
  106.                                                         key = tolower(key);
  107.                                                 else
  108.                                                         key = toupper(key);
  109.  
  110.                                         for (i = cmdLen+1; i > cmdPos; i--)
  111.                                             CMD[i] = CMD[i-1];
  112.  
  113.                                         CMD[cmdPos] = key;
  114.  
  115.                                         for (i = cmdPos; i > 0; i--)
  116.                                             printf("%c %c", 8, 8);
  117.  
  118.                                         printf("%s", CMD);
  119.  
  120.                                         for (i = 0; i < cmdLen-cmdPos; i++)
  121.                                             printf("%c", 8);
  122.  
  123.                                         cmdPos++;
  124.                                         cmdLen++;
  125.                                         }
  126.                                         break;
  127.  
  128.                         }
  129.                 }
  130.                 else
  131.                 {
  132.                 key = (key>>8)&0xff;
  133.                 switch (key)
  134.                         {
  135.                         case 83: // Del
  136.                              if (cmdPos < cmdLen)
  137.                                 {
  138.                                 for (i = cmdPos; i < cmdLen; i++)
  139.                                     CMD[i] = CMD[i+1];
  140.  
  141.                                 for (i = 0; i < cmdLen-cmdPos; i++)
  142.                                     printf(" ");
  143.  
  144.                                 for (i = 0; i < cmdLen-cmdPos; i++)
  145.                                     printf("%c", 8);
  146.  
  147.                                 for (i = cmdPos; i < cmdLen; i++)
  148.                                     printf("%c", CMD[i]);
  149.  
  150.                                 for (i = 0; i < cmdLen-cmdPos; i++)
  151.                                     printf("%c", 8);
  152.  
  153.                                 cmdLen--;
  154.                                 }
  155.  
  156.                              break;
  157.  
  158.                         case 75: // Left
  159.                              if (cmdPos > 0)
  160.                                 {
  161.                                 printf("%c", 8);
  162.                                 cmdPos--;
  163.                                 }
  164.                              break;
  165.  
  166.  
  167.                         case 77: // Right
  168.                              if (cmdPos < cmdLen)
  169.                                 {
  170.                                 printf("%c", CMD[cmdPos]);
  171.                                 cmdPos++;
  172.                                 }
  173.                              break;
  174.  
  175.  
  176.                         case 80: // Down
  177.                                 for (i = 0; i < CMD_HISTORY_NUM; i++)
  178.                                         {
  179.  
  180.                                         for (i = cmdPos; i < cmdLen; i++)
  181.                                             printf(" ");
  182.  
  183.                                         for (i = cmdLen; i > 0; i--)
  184.                                             printf("%c %c", 8, 8);
  185.  
  186.                                         if (CMD_NUM < CMD_HISTORY_NUM-1)
  187.                                                 CMD_NUM++;
  188.                                         else
  189.                                                 CMD_NUM = 0;
  190.  
  191.                                         printf( CMD_HISTORY[CMD_NUM] );
  192.                                         strcpy(CMD, CMD_HISTORY[CMD_NUM]);
  193.                                         cmdLen = strlen(CMD);
  194.                                         if ((cmdPos = strlen(CMD)) != 0)
  195.                                                 break;
  196.  
  197.                                         }
  198.  
  199.                                 break;
  200.  
  201.  
  202.                         case 72: // Up
  203.                                 for (i = 0; i < CMD_HISTORY_NUM; i++)
  204.                                         {
  205.  
  206.                                         for (i = cmdPos; i < cmdLen; i++)
  207.                                             printf(" ");
  208.  
  209.                                         for (i = cmdLen; i > 0; i--)
  210.                                             printf("%c %c", 8, 8);
  211.  
  212.                                         if (CMD_NUM > 0)
  213.                                                 CMD_NUM--;
  214.                                         else
  215.                                                 CMD_NUM = CMD_HISTORY_NUM-1;
  216.  
  217.                                         printf( CMD_HISTORY[CMD_NUM] );
  218.                                         strcpy(CMD, CMD_HISTORY[CMD_NUM]);
  219.                                         cmdLen = strlen(CMD);
  220.                                         if ((cmdPos = strlen(CMD)) != 0)
  221.                                                 break;
  222.                                         }
  223.                                 break;
  224.  
  225.  
  226.                         case 0: // console window closed
  227.                                 cmd_exit(NULL);
  228.  
  229.                         }
  230.  
  231.                 }
  232.         }
  233.  
  234. }
  235.  
  236. /// ===========================================================
  237.  
  238. int command_get_cmd(char cmd[])
  239. {
  240. unsigned i, len;
  241. int quote = 0;
  242.  
  243. if (CMD[0]=='"')
  244.    quote = 1;
  245.  
  246. if (quote == 0)
  247.    {
  248.    for (i=0;;i++)
  249.         {
  250.         cmd[i] = CMD[i];
  251.         if (0 == cmd[i])
  252.                 {
  253.                 i = -2;
  254.                 break;
  255.                 }
  256.         if ( iswhite(cmd[i]) )
  257.                 {
  258.                 cmd[i] = '\0';
  259.                 break;
  260.                 }
  261.         }
  262.    return i+1;
  263.    }
  264.    else
  265.    {
  266.    len = 0;
  267.    for (i=1;;i++)
  268.         {
  269.         cmd[len] = CMD[i];
  270.         if (0 == cmd[len])
  271.                 {
  272.                 len = -2;
  273.                 break;
  274.                 }
  275.         if ( cmd[len] == '"' )
  276.                 {
  277.                 cmd[len] = '\0';
  278.                 break;
  279.                 }
  280.         len++;
  281.         }
  282.    trim(cmd);
  283.    return len+2;
  284.    }
  285. }
  286.  
  287. /// ===========================================================
  288.  
  289. typedef int (*handler1_t)(char* arg);
  290.  
  291. /// ===========================================================
  292.  
  293. void command_execute()
  294. {
  295. char cmd[256];
  296. char args[256];
  297. unsigned arg;
  298. int i;
  299. int result;
  300.  
  301. trim(CMD);
  302. arg = command_get_cmd(cmd);
  303.  
  304. if ( !strlen(cmd) )
  305.         return;
  306.  
  307. strcpy(args, CMD+arg);
  308. trim(args);
  309.  
  310. for (i = 0; i < NUM_OF_CMD; i++)
  311.         {
  312.         if (!strcmp(cmd, COMMANDS[i].name))
  313.                 {
  314.                 result = ((handler1_t)COMMANDS[i].handler)(args);
  315.                 if (result != TRUE)
  316.                    {
  317.                    #if LANG_ENG
  318.                        printf("  Error!\n\r");
  319.                    #elif LANG_RUS
  320.                        printf("  Žè¨¡ª !\n\r");
  321.                    #endif
  322.                     }
  323.                 return;
  324.                 }
  325.         }
  326.  
  327.  
  328. if ( -1 != alias_search(CMD) )
  329.         {
  330.         strcpy(CMD, ALIASES+64*1024+256*alias_search(CMD));
  331.         command_execute();
  332.         return;
  333.         }
  334.  
  335. executable_run(cmd, args);
  336.  
  337. }
  338.  
  339. /// ===========================================================
  340.  
  341.