forksand
/
qmk_firmware
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Removed commented code from keymap

Browse Source
pull/2864/head
Ajax 7 years ago
parent a75589a099
commit 37d53113e6
1 changed files with 1 additions and 447 deletions
Show Stats Download Patch File Download Diff File

446
keyboards/dz60/keymaps/doogle999/keymap.c
Unescape View File

@ -71,449 +71,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
______, ______, ______, ______, ______, ______, KC_SLSH, ______, ______, ______, ______
),
};
/*
static char backspaceText[BUFFER_SIZE + 1]; // Pretty dumb waste of memory because only backspace characters, used with send_string to backspace and remove input
static char text[BUFFER_SIZE + 1]; // Used to store input and then output when ready to print
static unsigned char inputLocation = 0; // Current index in text input
double calc(char input[]) // Finds value of input char array, relatively small and fast I think
{
char inputToken[BUFFER_SIZE + 1]; // Input buffer, used when a single token (generally a number) takes up more
unsigned char inputTokenLocation = 0, inputLocation = 0; // Keep track of indices
struct Token tokens[BUFFER_SIZE + 1]; // Input, converted to tokens, one extra large to accomodate for possible negative sign then open parenthesis as first character
unsigned char tokenCount = 0; // Keep track of index
bool dashAsMinus = false; // Kind of a hacky solution to determining whether to treat a dash as a minus sign or a negative sign
while(inputLocation < BUFFER_SIZE)
{
short number = input[inputLocation] - '0'; // Using a short here because both signed char and unsigned char would overflow, potentially
if(inputLocation == 0 && input[inputLocation] == CHAR_SUB && input[inputLocation + 1] == CHAR_BEG)
{
tokens[tokenCount].raw.num = 0;
tokens[tokenCount].isNum = true;
tokenCount++;
dashAsMinus = true;
}
if((number < 10 && number >= 0) || (inputTokenLocation != 0 && input[inputLocation] == '.') || (!dashAsMinus && inputTokenLocation == 0 && input[inputLocation] == '-'))
{
inputToken[inputTokenLocation] = input[inputLocation];
inputTokenLocation++;
inputLocation++;
}
else
{
if(inputTokenLocation != 0)
{
// sscanf(inputToken, "%lf", &tokens[tokenCount].raw.num); // I would like to use sscanf here, but the small version of stdio.h on the chip doesn't allow sscanf or its sister functions to be used to process floats
tokens[tokenCount].raw.num = atof(inputToken);
tokens[tokenCount].isNum = true;
for(unsigned char i = 0; i < inputTokenLocation + 1; i++)
{
inputToken[i] = '\0';
}
inputTokenLocation = 0;
tokenCount++;
dashAsMinus = true;
}
tokens[tokenCount].isNum = false;
tokens[tokenCount].raw.op.c = input[inputLocation];
tokens[tokenCount].raw.op.priority = 0;
tokens[tokenCount].raw.op.ltr = true;
dashAsMinus = false;
switch(input[inputLocation])
{
case CHAR_BEG:
break;
case CHAR_END:
dashAsMinus = true;
break;
case CHAR_ADD:
tokens[tokenCount].raw.op.priority = PRIO_ADD;
break;
case CHAR_SUB:
tokens[tokenCount].raw.op.priority = PRIO_SUB;
break;
case CHAR_MUL:
tokens[tokenCount].raw.op.priority = PRIO_MUL;
break;
case CHAR_DIV:
tokens[tokenCount].raw.op.priority = PRIO_DIV;
break;
case CHAR_EXP:
tokens[tokenCount].raw.op.priority = PRIO_EXP;
tokens[tokenCount].raw.op.ltr = false;
break;
case CHAR_SIN:
break;
case CHAR_COS:
break;
case CHAR_TAN:
break;
case CHAR_ASN:
break;
case CHAR_ACS:
break;
case CHAR_ATN:
break;
case CHAR_LGE:
break;
case CHAR_LOG:
break;
case CHAR_SQT:
break;
case '\0':
tokenCount--;
inputLocation = BUFFER_SIZE;
break;
default:
tokenCount--;
break;
}
tokenCount++;
inputLocation++;
}
}
struct Token output[BUFFER_SIZE + 1]; // Final output tokens before evaluation
struct Token opstack[BUFFER_SIZE + 1]; // Stack of operators
unsigned char outputLocation = 0, opstackLocation = 0; // Keep track of indices
unsigned char numBrackets = 0; // The number of parenthesis
for(unsigned char i = 0; i < tokenCount; i++)
{
if(tokens[i].isNum)
{
output[outputLocation] = tokens[i];
outputLocation++;
}
else if(tokens[i].raw.op.c == CHAR_BEG)
{
opstack[opstackLocation] = tokens[i];
opstackLocation++;
}
else if(tokens[i].raw.op.c == CHAR_END)
{
while(opstack[opstackLocation - 1].raw.op.c != CHAR_BEG)
{
output[outputLocation] = opstack[opstackLocation - 1];
outputLocation++;
opstackLocation--;
}
opstackLocation--;
numBrackets += 2;
}
else if(tokens[i].raw.op.priority == 0)
{
opstack[opstackLocation] = tokens[i];
opstackLocation++;
}
else
{
while(opstackLocation != 0
&& (opstack[opstackLocation - 1].raw.op.priority == 0
|| tokens[i].raw.op.priority < opstack[opstackLocation - 1].raw.op.priority
|| (tokens[i].raw.op.priority == opstack[opstackLocation - 1].raw.op.priority && opstack[opstackLocation - 1].raw.op.ltr))
&& opstack[opstackLocation - 1].raw.op.c != CHAR_BEG)
{
output[outputLocation] = opstack[opstackLocation - 1];
outputLocation++;
opstackLocation--;
}
opstack[opstackLocation] = tokens[i];
opstackLocation++;
}
}
tokenCount -= numBrackets;
for(signed char i = opstackLocation - 1; i >= 0; i--)
{
output[outputLocation] = opstack[i];
outputLocation++;
opstackLocation--;
}
double answer[BUFFER_SIZE];
unsigned char answerLocation = 0;
for(unsigned char i = 0; i < tokenCount; i++)
{
if(output[i].isNum)
{
answer[answerLocation] = output[i].raw.num;
answerLocation++;
}
else
{
if(output[i].raw.op.priority == 0)
{
if(answerLocation >= 1)
{
switch(output[i].raw.op.c)
{
case CHAR_SIN:
answer[answerLocation - 1] = sin(answer[answerLocation - 1]);
break;
case CHAR_COS:
answer[answerLocation - 1] = cos(answer[answerLocation - 1]);
break;
case CHAR_TAN:
answer[answerLocation - 1] = tan(answer[answerLocation - 1]);
break;
case CHAR_ASN:
answer[answerLocation - 1] = asin(answer[answerLocation - 1]);
break;
case CHAR_ACS:
answer[answerLocation - 1] = acos(answer[answerLocation - 1]);
break;
case CHAR_ATN:
answer[answerLocation - 1] = atan(answer[answerLocation - 1]);
break;
case CHAR_LGE:
answer[answerLocation - 1] = log(answer[answerLocation - 1]);
break;
case CHAR_LOG:
answer[answerLocation - 1] = log10(answer[answerLocation - 1]);
break;
case CHAR_SQT:
answer[answerLocation - 1] = sqrt(answer[answerLocation - 1]);
break;
}
}
}
else if(answerLocation >= 2)
{
switch(output[i].raw.op.c)
{
case CHAR_ADD:
answer[answerLocation - 2] += answer[answerLocation - 1];
break;
case CHAR_SUB:
answer[answerLocation - 2] -= answer[answerLocation - 1];
break;
case CHAR_MUL:
answer[answerLocation - 2] *= answer[answerLocation - 1];
break;
case CHAR_DIV:
answer[answerLocation - 2] /= answer[answerLocation - 1];
break;
case CHAR_EXP:
answer[answerLocation - 2] = pow(answer[answerLocation - 2], answer[answerLocation - 1]);
break;
}
answerLocation--;
}
}
}
return answer[0];
}
bool process_record_user(uint16_t keycode, keyrecord_t *record)
{
bool numpadKeyPressed = false;
if(record->event.pressed)
{
if(!(get_mods() & MODS_SHIFT_MASK))
{
switch(keycode)
{
case KC_KP_0:
numpadKeyPressed = true;
break;
case KC_KP_1:
numpadKeyPressed = true;
break;
case KC_KP_2:
numpadKeyPressed = true;
break;
case KC_KP_3:
numpadKeyPressed = true;
break;
case KC_KP_4:
numpadKeyPressed = true;
break;
case KC_KP_5:
numpadKeyPressed = true;
break;
case KC_KP_6:
numpadKeyPressed = true;
break;
case KC_KP_7:
numpadKeyPressed = true;
break;
case KC_KP_8:
numpadKeyPressed = true;
break;
case KC_KP_9:
numpadKeyPressed = true;
break;
}
}
}
if(numpadKeyPressed && !(host_keyboard_leds() & (1 << USB_LED_NUM_LOCK)))
{
add_key(KC_NLCK);
send_keyboard_report();
}
if(biton32(layer_state) == 2)
{
char characterPressed = '\0';
bool forceReturnTrue = false;
if(record->event.pressed)
{
if(!(get_mods() & MODS_SHIFT_MASK))
{
switch(keycode)
{
case KC_0:
characterPressed = '0';
break;
case KC_1:
characterPressed = '1';
break;
case KC_2:
characterPressed = '2';
break;
case KC_3:
characterPressed = '3';
break;
case KC_4:
characterPressed = '4';
break;
case KC_5:
characterPressed = '5';
break;
case KC_6:
characterPressed = '6';
break;
case KC_7:
characterPressed = '7';
break;
case KC_8:
characterPressed = '8';
break;
case KC_9:
characterPressed = '9';
break;
case KC_MINUS:
characterPressed = CHAR_SUB;
break;
case KC_SLASH:
characterPressed = CHAR_DIV;
break;
case KC_S:
characterPressed = CHAR_SIN;
break;
case KC_C:
characterPressed = CHAR_COS;
break;
case KC_T:
characterPressed = CHAR_TAN;
break;
case KC_Q:
characterPressed = CHAR_SQT;
break;
case KC_L:
characterPressed = CHAR_LGE;
break;
case KC_DOT:
characterPressed = '.';
break;
case KC_BSPC:
if(inputLocation > 0)
{
inputLocation--;
}
forceReturnTrue = true;
break;
case KC_RSFT:
forceReturnTrue = true;
break;
case KC_LSFT:
forceReturnTrue = true;
break;
case CALC:
for(int i = 0; i < inputLocation; i++)
{
backspaceText[i] = (char)8;
}
send_string(backspaceText);
dtostrf(calc(text), 6, 6, text);
send_string(text);
for(unsigned char i = 0; i < BUFFER_SIZE; i++)
{
text[i] = '\0';
backspaceText[i] = '\0';
}
inputLocation = 0;
break;
case ENDCALC:
layer_state = 0;
break;
default:
break;
}
}
else
{
switch(keycode)
{
case KC_9:
characterPressed = CHAR_BEG;
break;
case KC_0:
characterPressed = CHAR_END;
break;
case KC_EQUAL:
characterPressed = CHAR_ADD;
break;
case KC_6:
characterPressed = CHAR_EXP;
break;
case KC_8:
characterPressed = CHAR_MUL;
break;
case KC_S:
characterPressed = CHAR_ASN;
break;
case KC_C:
characterPressed = CHAR_ACS;
break;
case KC_T:
characterPressed = CHAR_ATN;
break;
case KC_L:
characterPressed = CHAR_LOG;
break;
default:
break;
}
}
}
if(inputLocation < BUFFER_SIZE && characterPressed != '\0')
{
text[inputLocation] = characterPressed;
inputLocation++;
}
return (!record->event.pressed || (record->event.pressed && (characterPressed != '\0' || forceReturnTrue)));
}
else
{
return true;
}
}
*/
Write Preview
Loading…
Cancel
Save