Subversion Repositories Kolibri OS

Rev

Rev 4309 | Rev 5207 | 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. int clipNum; // number of clipboard slots
  39. char* clipBuf; // clipboard buffer
  40. char clipCopy[255+12];
  41.  
  42. for (;;)
  43.         {
  44.         key = getch();
  45.         if ( 0 != (key & 0xff) )
  46.                 {
  47.                 key &= 0xff;
  48.                 switch (key)
  49.                         {
  50.                         case 27: // ESC
  51.                                 for (i = cmdPos; i < cmdLen; i++)
  52.                                     printf(" ");
  53.                                 for (i = cmdLen; i > 0; i--)
  54.                                     printf("%c %c", 8, 8);
  55.                                 cmdLen = 0;
  56.                                 cmdPos = 0;
  57.                                 CMD[0] = '\0';
  58.                                 break;
  59.  
  60.  
  61.                         case 13: // ENTER
  62.                                 printf("\n\r");
  63.                                 command_history_add();
  64.                                 return;
  65.  
  66.  
  67.                         case 8: // BACKSPACE
  68.                                 if (cmdPos > 0)
  69.                                         {
  70.                                         for (i = cmdPos-1; i < cmdLen; i++)
  71.                                                                                         CMD[i] = CMD[i+1];
  72.  
  73.                                         for (i = 0; i < cmdLen-cmdPos; i++)
  74.                                             printf (" ");
  75.  
  76.                                         for (i = 0; i < cmdLen; i++)
  77.                                             printf ("%c %c", 8, 8);
  78.  
  79.                                         printf("%s", CMD);
  80.  
  81.                                         for (i = 0; i < cmdLen-cmdPos; i++)
  82.                                             printf("%c", 8);
  83.  
  84.                                         cmdPos--;
  85.                                         cmdLen--;
  86.                                         }
  87.                                 break;
  88.  
  89.  
  90.                         case 9: // TAB
  91.                                 break;
  92.                                
  93.                                
  94.                         case 22: // Ctrl+V
  95.                                 clipNum = kol_clip_num();
  96.                                 if (clipNum > 0)
  97.                                         {
  98.                                         clipBuf = kol_clip_get(clipNum-1);
  99. //                                      printf("Length: %d, Type: %d, Encoding: %d\n", (int) *clipBuf, (int)*(clipBuf+4), (int)*(clipBuf+8));
  100.                                         if ( (int) *clipBuf > 0 ) // is clipboard empty?
  101.                                                 {
  102.                                                 if ((int)*(clipBuf+4)==0) // text?
  103.                                                         {
  104.                                                         if ((int)*(clipBuf+8)==1) // 866 encoding?
  105.  
  106.                                 for (i = cmdPos; i < cmdLen; i++)
  107.                                     printf(" ");
  108.                                 for (i = cmdLen; i > 0; i--)
  109.                                     printf("%c %c", 8, 8);
  110.                                 cmdLen = 0;
  111.                                 cmdPos = 0;
  112.                                 CMD[0] = '\0';
  113.  
  114.                                                                 // strcpy_n
  115.                                                                 for (i = 0; i < 255; i++)
  116.                                                                         {
  117.                                                                         CMD[i]=*(clipBuf+12+i);
  118.                                                                         if (CMD[i]=='\0')
  119.                                                                                 break;
  120.                                                                         }
  121.                                                                
  122.                                                                 cmdPos = cmdLen = strlen(CMD);
  123. /*                                                             
  124.                                                                 printf("Length: %d\n", cmdLen);
  125.                                                                 for (i = 0; i < cmdLen; i++)
  126.                                                                         printf("%d ", CMD[i]);
  127. */
  128.                                                                 printf("%s", CMD);
  129.  
  130.                                                                 }
  131.                                                 }
  132.                                         }
  133.                                 break;
  134.  
  135.                                
  136.                         case 3: // Ctrl+C
  137.                                 if ( cmdLen > 0 )
  138.                                         {
  139.                                        
  140.                                         *clipCopy = 12 + cmdLen;
  141.                                         *(clipCopy+4)=0;
  142.                                         *(clipCopy+8)=1;
  143.                                        
  144.                                         for (i = 0; i <= cmdLen; i++)
  145.                                                 *(clipCopy+12+i) = CMD[i];
  146.                                                
  147.                                         kol_clip_set(12+cmdLen, clipCopy);
  148.                                        
  149.                                         }
  150.                                 break;                         
  151.                                
  152.                                
  153.                         default:
  154.                                 if (cmdLen < 255)
  155.                                         {
  156.                                         if ( kol_key_control() & 0x40 ) // ¥á«¨ ¢ª«îçñ­ CapsLock
  157.                                                 if ( (kol_key_control() & 1) || (kol_key_control() & 2)) // ¥á«¨ ­ ¦ âë è¨äâë
  158.                                                         key = tolower(key);
  159.                                                 else
  160.                                                         key = toupper(key);
  161.  
  162.                                         for (i = cmdLen+1; i > cmdPos; i--)
  163.                                                 CMD[i] = CMD[i-1];
  164.  
  165.                                         CMD[cmdPos] = key;
  166.  
  167.                                         for (i = cmdPos; i > 0; i--)
  168.                                                 printf("%c %c", 8, 8);
  169.  
  170.                                         printf("%s", CMD);
  171.  
  172.                                         for (i = 0; i < cmdLen-cmdPos; i++)
  173.                                                 printf("%c", 8);
  174.  
  175.                                         cmdPos++;
  176.                                         cmdLen++;
  177.                                         }
  178.                                         break;
  179.  
  180.                         }
  181.                 }
  182.         else
  183.                         {
  184.                 key = (key>>8)&0xff;
  185.                         switch (key)
  186.                                 {
  187.                         case 83: // Del
  188.                              if (cmdPos < cmdLen)
  189.                                 {
  190.                                 for (i = cmdPos; i < cmdLen; i++)
  191.                                     CMD[i] = CMD[i+1];
  192.  
  193.                                 for (i = 0; i < cmdLen-cmdPos; i++)
  194.                                     printf(" ");
  195.  
  196.                                 for (i = 0; i < cmdLen-cmdPos; i++)
  197.                                     printf("%c", 8);
  198.  
  199.                                 for (i = cmdPos; i < cmdLen; i++)
  200.                                     printf("%c", CMD[i]);
  201.  
  202.                                 for (i = 0; i < cmdLen-cmdPos; i++)
  203.                                     printf("%c", 8);
  204.  
  205.                                 cmdLen--;
  206.                                 }
  207.  
  208.                              break;
  209.  
  210.                         case 75: // Left
  211.                              if (cmdPos > 0)
  212.                                 {
  213.                                 printf("%c", 8);
  214.                                 cmdPos--;
  215.                                 }
  216.                              break;
  217.  
  218.  
  219.                         case 77: // Right
  220.                              if (cmdPos < cmdLen)
  221.                                 {
  222.                                 printf("%c", CMD[cmdPos]);
  223.                                 cmdPos++;
  224.                                 }
  225.                              break;
  226.  
  227.  
  228.                         case 80: // Down
  229.  
  230.                                 if (CMD_HISTORY_NUM_REAL > 0)
  231.                                         {
  232.  
  233.                                         for (i = cmdPos; i < cmdLen; i++)
  234.                                                 printf(" ");
  235.  
  236.                                         for (i = cmdLen; i > 0; i--)
  237.                                                 printf("%c %c", 8, 8);
  238.  
  239.                                     if (CMD_NUM < CMD_HISTORY_NUM_REAL-1)
  240.                                         CMD_NUM++;
  241.                                     else
  242.                                                 CMD_NUM = 0;
  243.  
  244.                                         printf( "%s", CMD_HISTORY[CMD_NUM] );
  245.                                         strcpy(CMD, CMD_HISTORY[CMD_NUM]);
  246.                                         cmdLen = strlen(CMD);
  247.                                         cmdPos = strlen(CMD);
  248.  
  249.                                         }
  250.                        
  251.                                 break;
  252.  
  253.  
  254.                         case 72: // Up
  255.                                 if (CMD_HISTORY_NUM_REAL > 0)
  256.                                         {
  257.  
  258.                                         for (i = cmdPos; i < cmdLen; i++)
  259.                                                 printf(" ");
  260.  
  261.                                         for (i = cmdLen; i > 0; i--)
  262.                                                 printf("%c %c", 8, 8);
  263.  
  264.                                     if (CMD_NUM > 0)
  265.                                         CMD_NUM--;
  266.                                     else
  267.                                                 CMD_NUM = CMD_HISTORY_NUM_REAL-1;
  268.  
  269.                                         printf( "%s", CMD_HISTORY[CMD_NUM] );
  270.                                         strcpy(CMD, CMD_HISTORY[CMD_NUM]);
  271.                                         cmdLen = strlen(CMD);
  272.                                         cmdPos = strlen(CMD);
  273.  
  274.                                         }
  275.                                 break;
  276.  
  277.  
  278.                         case 0: // console window closed
  279.                                 cmd_exit(NULL);
  280.  
  281.                         }
  282.  
  283.                 }
  284.         }
  285.  
  286. }
  287.  
  288. /// ===========================================================
  289.  
  290. int command_get_cmd(char cmd[])
  291. {
  292. unsigned i, len;
  293. int quote = 0;
  294.  
  295. if (CMD[0]=='"')
  296.    quote = 1;
  297.  
  298. if (quote == 0)
  299.    {
  300.    for (i=0;;i++)
  301.         {
  302.         cmd[i] = CMD[i];
  303.         if (0 == cmd[i])
  304.                 {
  305.                 i = -2;
  306.                 break;
  307.                 }
  308.         if ( iswhite(cmd[i]) )
  309.                 {
  310.                 cmd[i] = '\0';
  311.                 break;
  312.                 }
  313.         }
  314.    return i+1;
  315.    }
  316.    else
  317.    {
  318.    len = 0;
  319.    for (i=1;;i++)
  320.         {
  321.         cmd[len] = CMD[i];
  322.         if (0 == cmd[len])
  323.                 {
  324.                 len = -2;
  325.                 break;
  326.                 }
  327.         if ( cmd[len] == '"' )
  328.                 {
  329.                 cmd[len] = '\0';
  330.                 break;
  331.                 }
  332.         len++;
  333.         }
  334.    trim(cmd);
  335.    return len+2;
  336.    }
  337. }
  338.  
  339. /// ===========================================================
  340.  
  341. typedef int (*handler1_t)(char* arg);
  342.  
  343. /// ===========================================================
  344.  
  345. void command_execute()
  346. {
  347. char cmd[256];
  348. char args[256];
  349. unsigned arg;
  350. int i;
  351. int result;
  352.  
  353. trim(CMD);
  354. arg = command_get_cmd(cmd);
  355.  
  356. if ( !strlen(cmd) )
  357.         return;
  358.  
  359. strcpy(args, CMD+arg);
  360. trim(args);
  361.  
  362. for (i = 0; i < NUM_OF_CMD; i++)
  363.         {
  364.         if (!strcmp(cmd, COMMANDS[i].name))
  365.                 {
  366.                 result = ((handler1_t)COMMANDS[i].handler)(args);
  367.                 if (result != TRUE)
  368.                    {
  369.                    #if LANG_ENG
  370.                        printf("  Error!\n\r");
  371.                    #elif LANG_RUS
  372.                        printf("  Žè¨¡ª !\n\r");
  373.                    #endif
  374.                     }
  375.                 return;
  376.                 }
  377.         }
  378.  
  379.  
  380. if ( -1 != alias_search(CMD) )
  381.         {
  382.         strcpy(CMD, ALIASES+64*1024+256*alias_search(CMD));
  383.         command_execute();
  384.         return;
  385.         }
  386.  
  387. executable_run(cmd, args);
  388.  
  389. }
  390.  
  391. /// ===========================================================
  392.  
  393.