Subversion Repositories Kolibri OS

Rev

Rev 7787 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

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