Subversion Repositories Kolibri OS

Rev

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

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