Subversion Repositories Kolibri OS

Rev

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