1. Си / Говнокод #28869

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    int let_past(data *base, char *infix, char *post_infix) {
      char *buffer;
    
      int past_in_table_cons_or_value(data * table, char *str_tok);
      int data_adress = 0;
      int lng = 0;
      int left_side = 0;
    
      past_in_table_cons_or_value(base, &infix[0]);
    
      buffer = strtok(&infix[1], "  ");
    
      for (; buffer != (char *)'\0';
           post_infix[lng++] = ' ', buffer = strtok(NULL, " ")) {
    
        if (isalnum(*buffer)) {
    
          data_adress = past_in_table_cons_or_value(base, buffer);
    
          sprintf(&post_infix[lng], "%d", data_adress);
    
          lng += 2;
        }
    
        else {
          post_infix[lng] = *buffer;
          lng++;
        }
      }
    
      post_infix[lng] = '\0';
      left_side = search_in_table(base, &infix[0]);
    
      return (base + left_side)->location;
    }
    
    int my_strcmp (const char *out, const char *in   ){
      for( ;*(in) , *(out) &&  *(in) == *(out); *out++,*in++  );
    	   return   *in <= *out ?  *out > *in   : -1   ;
    	}

    Инклуды длясимплтрона 4

    gne4do, 02 Октября 2023

    Комментарии (0)
  2. Си / Говнокод #28868

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    79. 79
    80. 80
    81. 81
    82. 82
    83. 83
    84. 84
    85. 85
    int pop_2(StackNodePtr_2 *topPtr) {
      StackNodePtr_2 tempPtr;
      int popValue;
    
      tempPtr = *topPtr;
      popValue = (*topPtr)->data;
      *topPtr = (*topPtr)->nextPtr;
      free(tempPtr);
    
      return popValue;
    }
    
    /* Return the value at the top of the stack */
    char stackTop_1(StackNodePtr_2 topPtr) {
      char topValue;
    
      topValue = topPtr->data;
    
      return topValue;
    }
    
    int isEmpty_2(StackNodePtr_2 topPtr) { return topPtr == NULL; }
    
    /* Test if the list is empty */
    
    int my_isalpha(char alpha) {
      return ((alpha >= 65 && alpha <= 90) || (alpha >= 97 && alpha <= 122));
    }
    
    int my_isdigit(char alpha) { return (alpha >= 48) && (alpha <= 57); }
    
    int isOperator_2(char c) {
    
      return c == '/' || c == '*' || c == '-' || c == '+' || c == '^' || c == '%';
    }
    
    int goto_search(data *table, char *token) {
    
      int x = 0;
    
      for (x = 0; x != 100; x++) {
    
        if (memcmp((table + x)->symbol, token, 2) == 0) {
          return (table + x)->location;
        }
      }
      return 0;
    }
    
    int helper_search_1(data *base, char *token, int run) {
      return ((base + run)->symbol[0] == *token ||
              my_strcmp((base + run)->symbol, "0") == 0);
    }
    
    int helper_search_2(data *base, char *token, int run) {
      return (my_strcmp((base + run)->symbol, token) == 0 ||
              my_strcmp((base + run)->symbol, "0") == 0);
    }
    
    int search_in_base(data *intro_search, char *str_tok_search) {
    
      int runner = 0, ch = !my_isalpha(*str_tok_search);
      for (; !helper_search_base(intro_search, str_tok_search, runner); ++runner)
        ;
      return runner;
    }
    int helper_search_base(data *base, char *token, int run) {
      return my_strcmp((base + run)->symbol, "0") == 0;
    }
    
    int search_in_table(data *intro_search, char *str_tok_search) {
    
      int runner = 0, ch = !my_isalpha(*str_tok_search);
      for (; !(*helper_search[ch])(intro_search, str_tok_search, runner); ++runner)
        ;
      return runner;
    }
    
    int rem_break(char *token) {
    
      if (memcmp(token, "rem", 3) == 0) {
        return 1;
      }
      return 0;
    }

    Инклуды для симплтрона

    gne4do, 02 Октября 2023

    Комментарии (0)
  3. Си / Говнокод #28867

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    79. 79
    80. 80
    81. 81
    82. 82
    83. 83
    84. 84
    85. 85
    86. 86
    87. 87
    88. 88
    89. 89
    90. 90
    91. 91
    92. 92
    93. 93
    /* Do the conversion */
      while (!isEmpty_2(stackPtr) && infix[i] != '\0') {
        c = infix[i++];
    
        if (my_isdigit(c) || my_isalpha(c)) {
          while (my_isdigit(c) || my_isalpha(c)) {
            postfix[j++] = c;
            c = infix[i++];
          }
          postfix[j++] = ' ';
    
          if (c == ')' || isOperator_2(c))
            i--;
        } else if (c == '(')
          push_2(&stackPtr, '(');
        else if (isOperator_2(c) == 1) {
          if (!isEmpty_2(stackPtr) && isOperator_2(stackTop_1(stackPtr))) {
            while (isOperator_2(stackTop_1(stackPtr)) &&
                   (precedence_1(stackTop_1(stackPtr), c)) >= 0) {
              postfix[j++] = pop_2(&stackPtr);
              postfix[j++] = ' ';
            }
            push_2(&stackPtr, c);
          } else
            push_2(&stackPtr, c);
        } else if (c == ')') {
          if (!isEmpty_2(stackPtr)) {
            c = pop_2(&stackPtr);
    
            while (!isEmpty_2(stackPtr) && c != '(') {
              postfix[j++] = c;
              postfix[j++] = ' ';
              c = pop_2(&stackPtr);
            }
          }
        }
      }
      postfix[j] = '\0';
    }
    
    int precedence_1(char operator1, char operator2) {
      int result = 1;
    
      switch (operator1) {
      case '^':
        if (operator2 == '^')
          result = 0;
        break;
      case '*':
      case '/':
      case '%':
        switch (operator2) {
        case '^':
          result = -1;
          break;
        case '*':
        case '/':
        case '%':
          result = 0;
          break;
        default:
          break;
        }
        break;
      case '+':
      case '-':
        switch (operator2) {
        case '-':
        case '+':
          result = 0;
          break;
        default:
          result = -1;
          break;
        }
        break;
      }
    
      return result;
    }
    
    void push_2(StackNodePtr_2 *topPtr, int info) {
      StackNodePtr_2 newPtr;
    
      newPtr = malloc(sizeof(StackNode_2)); /* Now points to a place in memory*/
    
      if (newPtr != NULL) {
        newPtr->data = info;
        newPtr->nextPtr = *topPtr;
        *topPtr = newPtr;
      } else
        printf("%c not inserted. No memory available.\n", info);
    }

    Инклуды для симплтрона 2

    gne4do, 02 Октября 2023

    Комментарии (0)
  4. Си / Говнокод #28866

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    #include <ctype.h> 
    #include <math.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #define MEM 100
    #define READ 10
    #define WRITE 11
    #define LOAD 20
    #define STORE 21
    #define ADD 30
    #define SUBSTRACT 31
    #define DIVIDE 32
    #define MUL 33
    #define BRANCH 40
    #define BRANCHNEG 41
    #define BRANCHZERO 42
    #define HALT 43
    
    int count_down = 99;
    
    struct stackNode_2 {
      int data;
      struct stackNode_2 *nextPtr;
    };
    
    typedef struct stackNode_2 StackNode_2;
    typedef StackNode_2 *StackNodePtr_2;
    
    typedef struct tableEntry {
      char symbol[10];
      char type;
      int location;
    
    } data;
    
    int my_isdigit(char alpha);
    int my_isalpha(char alpha);
    int isOperator_2(char c);
    
    char stackTop_1(StackNodePtr_2 topPtr);
    
    int helper_search_1(data *base, char *token, int run);
    
    int helper_search_2(data *base, char *token, int run);
    
    int (*helper_search[2])(data *base, char *token, int run) = {helper_search_1,
                                                                 helper_search_2};
    
    int search_in_base(data *intro_search, char *str_tok_search);
    int helper_search_base(data *base, char *token, int run);
    
    void convertToPostfix_1(char infix[], char postfix[]);
    
    int pop_2(StackNodePtr_2 *topPtr);
    void push_2(StackNodePtr_2 *topPtr, int info);
    int isEmpty_2(StackNodePtr_2 topPtr);
    
    int precedence_1(char operator1, char operator2);
    
    void convertToPostfix_1(char infix[], char postfix[]) {
      int i = 0, j = 0;
      char c;
    
      /* Push left parenthesis to stack */
      StackNodePtr_2 stackPtr = NULL;
      push_2(&stackPtr, '(');
    
      /* Add right parenthesis to end of infix */
      while (infix[i] != '\0')
        i++;
    
      infix[i++] = ')';
      infix[i] = '\0';
    
      i = 0;

    Инклуды для симплтрона 1

    gne4do, 02 Октября 2023

    Комментарии (0)
  5. Си / Говнокод #28865

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    int calculate_2(int op1, int op2, char operator, int memory_smp[],
                    int *count_command) {
    
      int result = 0;
    
      switch (operator) {
      case '+':
    
        memory_smp[*count_command] = (2000 + op1);
        (*count_command)++;
    
        memory_smp[*count_command] = (3000 + op2);
        (*count_command)++;
    
        memory_smp[*count_command] = (2100 + count_down);
    
        (*count_command)++;
        result = count_down;
        count_down--;
    
        // result = op1 + op2;
        break;
      case '-':
        memory_smp[*count_command] = (2000 + op1);
        (*count_command)++;
        memory_smp[*count_command] = (3100 + op2);
        (*count_command)++;
        memory_smp[*count_command] = (2100 + count_down);
        (*count_command)++;
        result = count_down;
        count_down--;
        // result = op1 - op2;
        break;
      case '*':
        memory_smp[*count_command] = (2000 + op1);
        (*count_command)++;
        memory_smp[*count_command] = (3300 + op2);
        (*count_command)++;
        memory_smp[*count_command] = (2100 + count_down);
        (*count_command)++;
        result = count_down;
        count_down--;
        // result = op1 * op2;
        break;
      case '/':
    
        memory_smp[*count_command] = (2000 + op1);
        (*count_command)++;
        memory_smp[*count_command] = (3200 + op2);
        (*count_command)++;
        memory_smp[*count_command] = (2100 + count_down);
        (*count_command)++;
        result = count_down;
        count_down--;
        //   result = op1 / op2;
        break;
      /*
      case '^':
        result = pow(op1, op2);
        break;
      case '%':
        result = op1 % op2;
        break;
      */
      default:
        break;
      }
    
      return result;
    }

    Симлтрон из Дейтелов
    5

    gne4do, 02 Октября 2023

    Комментарии (0)
  6. Си / Говнокод #28864

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    79. 79
    80. 80
    81. 81
    82. 82
    83. 83
    84. 84
    85. 85
    86. 86
    87. 87
    88. 88
    89. 89
    90. 90
    91. 91
    92. 92
    93. 93
    94. 94
    95. 95
    file_buf = fopen(argv[2], "w");
    
      for (d = 0; mem_smp[d] != 0; d++) {
    
        fprintf(file_buf, "%d %d\n", d, mem_smp[d]);
      }
    
      for (d = 0; (symbolTable + d)->type != 'q'; d++) {
    
        if ((symbolTable + d)->type == 'C') {
          count_cmd = atoi((symbolTable + d)->symbol);
    
          fprintf(file_buf, "%d %d\n", (symbolTable + d)->location, count_cmd);
        }
      }
      fclose(file_buf);
    
      return 0;
    }
    
    int past_in_table_cons_or_value(data *table, char *str_tok) {
    
      int search_in_table(data * intro_search, char *str_tok_search);
    
      int find = search_in_table(table, str_tok);
    
      if ((table + find)->type == 'q') {
    
        if (my_isalpha(*str_tok)) {
          (table + find)->symbol[0] = *str_tok; //  or  str_tok don't atoi
    
        } else {
          strcpy((table + find)->symbol, str_tok);
        }
    
        (table + find)->type = my_isalpha(*str_tok) ? 'V' : 'C';
    
        (table + find)->location = count_down;
    
        count_down--;
      }
    
      return (table + find)->location;
    }
    
    int evaluatePostfixExpression_2(char *expr, int memory_smp[],
                                    int *count_command) {
      StackNodePtr_2 stackPtr = NULL;
      char c;
      int x, y;
      int i = 0, mult = 1, num = 0;
    
      while (expr[i] != '\0') {
        mult = 1;
        num = 0;
        c = expr[i];
        if (my_isdigit(c)) {
          while (my_isdigit(c)) {
            num *= mult;
            num += c - 48;
            c = expr[++i];
            mult *= 10;
          }
          --i;
          push_2(&stackPtr, num);
        } else if (isOperator_2(c)) {
          if (isEmpty_2(stackPtr)) {
            printf("Invalid postfix expression!\n");
            return 0;
          }
          x = pop_2(&stackPtr);
    
          if (isEmpty_2(stackPtr)) {
            printf("Invalid postfix expression!\n");
            return 0;
          }
          y = pop_2(&stackPtr);
    
          push_2(&stackPtr, calculate_2(y, x, c, memory_smp, &(*count_command)));
        }
        i++;
      }
    
      if (isEmpty_2(stackPtr)) {
        printf("Invalid postfix expression!\n");
        return 0;
      }
    
      return pop_2(&stackPtr);
    }
    
    int calculate_2(int op1, int op2, char operator, int memory_smp[],
                    int *count_command) {
    
      int result = 0;

    Симплтрон из задачи Дейтелов
    4

    gne4do, 02 Октября 2023

    Комментарии (0)
  7. Си / Говнокод #28863

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    79. 79
    80. 80
    81. 81
    82. 82
    83. 83
    84. 84
    85. 85
    86. 86
    87. 87
    88. 88
    89. 89
    90. 90
    91. 91
    92. 92
    93. 93
    94. 94
    95. 95
    96. 96
    if (sign_ch == 0) {
              swp = val_if[0];
              val_if[0] = val_if[1];
              val_if[1] = swp;
            }
    
            mem_smp[count_cmd] = 2000 + (symbolTable + val_if[1])->location;
            count_cmd++;
            mem_smp[count_cmd] = 3100 + (symbolTable + val_if[0])->location;
            count_cmd++;
    
            if (goto_flag == 1) {
              flags[count_cmd] = second_buf;
              mem_smp[count_cmd] = rn_data[ab].data[0];
              count_cmd++;
            } else {
              mem_smp[count_cmd] = rn_data[ab].data[0] + second_buf;
              count_cmd++;
            }
    
            if (rn_data[ab].type == 2) {
    
              mem_smp[count_cmd] = 2000 + (symbolTable + val_if[0])->location;
              count_cmd++;
              mem_smp[count_cmd] = 3100 + (symbolTable + val_if[1])->location;
              count_cmd++;
    
              if (goto_flag == 1) {
                flags[count_cmd] = second_buf;
                mem_smp[count_cmd] = rn_data[ab].data[1];
                count_cmd++;
              } else {
                mem_smp[count_cmd] = rn_data[ab].data[1] + second_buf;
                count_cmd++;
              }
            }
    
          }
    
          else if (my_strcmp(buffer, "goto") == 0) {
    
            second_buf = 0;
            goto_flag = 0;
    
            intro_buffer = strtok(NULL, " ");
            second_buf = goto_search(symbolTable, intro_buffer);
    
            if (second_buf == 0) {
              second_buf = atoi(intro_buffer);
              goto_flag = 1;
            }
    
            if (goto_flag == 1) {
              flags[count_cmd] = second_buf;
              mem_smp[count_cmd] = 4000;
              count_cmd++;
            } else {
              mem_smp[count_cmd] = 4000 + second_buf;
              count_cmd++;
            }
          }
    
          else if (my_strcmp(buffer, "print") == 0) {
            intro_buffer = strtok(NULL, " ");
            second_buf = search_in_table(symbolTable, intro_buffer);
            mem_smp[count_cmd] = 1100 + (symbolTable + second_buf)->location;
            count_cmd++;
    
          }
    
          else if (my_strcmp(buffer, "input") == 0) {
            intro_buffer = strtok(NULL, " ");
            past_in_table_cons_or_value(symbolTable, intro_buffer);
            second_buf = search_in_table(symbolTable, intro_buffer);
            mem_smp[count_cmd] = 1000 + (symbolTable + second_buf)->location;
            count_cmd++;
          } else if (my_strcmp(buffer, "end") == 0) {
    
            mem_smp[count_cmd] = 4300;
          }
    
          ////////////////////////////////////////////////////////////////////////
          count_table_extra = count_cmd;
          /////////////////////////////////////////////////////////////////////////
        }
      }
    
      for (d = 0; mem_smp[d] != 0; d++) {
        if (flags[d] != -1) {
    
          sprintf(&postfix[0], "%d", flags[d]);
    
          goto_flag = search_in_table(symbolTable, postfix);
          mem_smp[d] += (symbolTable + goto_flag)->location;
        }
      }

    Симплтрон из задачи Дейтелов
    3

    gne4do, 02 Октября 2023

    Комментарии (0)
  8. Си / Говнокод #28862

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    79. 79
    80. 80
    81. 81
    82. 82
    83. 83
    84. 84
    85. 85
    86. 86
    87. 87
    88. 88
    89. 89
    90. 90
    91. 91
    92. 92
    93. 93
    94. 94
    95. 95
    96. 96
    97. 97
    98. 98
    int second_buf = 0;
    
      for (; d != 100; d++) {
    
        strcpy((symbolTable + d)->symbol, "0");
        (symbolTable + d)->location = 0;
        (symbolTable + d)->type = 'q';
        mem_smp[d] = 0;
        flags[d] = -1;
      }
    
      printf("%s\n", argv[0]);
    
      file_buf = fopen(argv[1], "r");
    
      for (d = 0; feof(file_buf) == 0; ++d) {
    
        fgets(&buf_data[d][0], 150, file_buf);
      }
    
      fclose(file_buf);
    
      memcpy(copy_buf_data, buf_data, sizeof(char) * 150 * 150);
    
      for (d = 0; buf_data[d][0] != 0; d++) {
    
        buffer = strtok(&buf_data[d][0], " ");
    
        for (; buffer != NULL; buffer = strtok(NULL, " ")) {
    
          if (token_string_count == 0 && my_isdigit(*buffer)) {
    
            count_table_intro = search_in_base(symbolTable, buffer);
    
            strcpy((symbolTable + count_table_intro)->symbol, buffer);
    
            (symbolTable + count_table_intro)->type = 'L';
    
            (symbolTable + count_table_intro)->location = count_table_extra;
          }
    
          if (rem_break(buffer) == 1) {
    
            (symbolTable + count_table_intro)->location = count_table_extra;
    
            break;
          }
    
          else if (my_strcmp(buffer, "let") == 0) {
    
            strcpy(infix, &copy_buf_data[d][7]);
            convertToPostfix_1(infix, postfix);
            save_left_side = let_past(symbolTable, postfix, post_buf);
    
            save_exp = evaluatePostfixExpression_2(post_buf, mem_smp, &count_cmd);
            mem_smp[count_cmd] = (2000 + save_exp);
            count_cmd++;
    
            mem_smp[count_cmd] = (2100 + save_left_side);
            count_cmd++;
    
          }
    
          else if (my_strcmp(buffer, "if") == 0) {
    
            strcpy(infix, &copy_buf_data[d][5]);
            intro_buffer = strtok(infix, " ");
            second_buf = 0;
            for (count_if = 0, sign_ch = 1, ab = 0; intro_buffer != (char *)'\0';
                 intro_buffer = strtok(NULL, " "), count_if++) {
    
              if (!my_strcmp(intro_buffer, "goto")) {
                goto_flag = 0;
                intro_buffer = strtok(NULL, " ");
    
                second_buf = goto_search(symbolTable, intro_buffer);
    
                if (second_buf == 0) {
                  second_buf = atoi(intro_buffer);
                  goto_flag = 1;
                }
    
              }
    
              else if (strstr(comparison_signs, intro_buffer)) {
                ab = intro_buffer[0] + intro_buffer[1];
    
                sign_ch = !(ab == 60);
    
              }
    
              else if ((isalnum(*intro_buffer))) {
    
                past_in_table_cons_or_value(symbolTable, intro_buffer);
    
                val_if[cnt++] = search_in_table(symbolTable, intro_buffer);
              }
            }

    Симплтрон из задачи Дейтелов
    2

    gne4do, 02 Октября 2023

    Комментарии (0)
  9. Си / Говнокод #28861

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    79. 79
    80. 80
    81. 81
    82. 82
    83. 83
    84. 84
    85. 85
    86. 86
    87. 87
    88. 88
    89. 89
    90. 90
    91. 91
    92. 92
    93. 93
    94. 94
    95. 95
    96. 96
    97. 97
    98. 98
    #include <ctype.h>
    #include <math.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    int evaluatePostfixExpression_2(char *, int memory_smp[], int *count_command);
    int calculate_2(int, int, char, int memory_smp[], int *count_command);
    
    typedef struct mode_intro {
      int type;
      int data[2];
    
    } expr_if;
    
    int main(int argc, char *argv[]) {
    
      expr_if rn_data[125];
    
      /*  !=   */
      rn_data[94].type = 2;
      rn_data[94].data[0] = 4100;
      rn_data[94].data[1] = 4100;
      /*  !=   */
    
      /*  ==   */
      rn_data[122].type = 1;
      rn_data[122].data[0] = 4200;
      /*  ==   */
    
      /*  <=   */
      rn_data[121].type = 2;
      rn_data[121].data[0] = 4200;
      rn_data[121].data[1] = 4100;
      /*  <=   */
    
      /* < Øèâîðîò íà âûâîðîò  */
      rn_data[60].type = 1;
      rn_data[60].data[0] = 4100;
      /*  <   */
    
      /*  >=   */
      rn_data[123].type = 2;
      rn_data[123].data[0] = 4200;
      rn_data[123].data[1] = 4100;
      /*  >=   */
    
      /* > */
      rn_data[62].type = 1;
      rn_data[62].data[0] = 4100;
      /* > */
    
      char infix[150];
      char postfix[150];
    
      int line_simple_comands_input_print(int cmd, data *table, int token,
                                          int memory[]);
    
      int past_in_table_cons_or_value(data * table, char *str_tok);
      int ab = 0;
      int swp = 0;
      int goto_search(data * table, char *token);
    
      int search_cmd(char *dict[15], char *token);
      char *comparison_signs = "> < <= >= == !=";
      int token_string_count = 0;
      data symbolTable[100];
    
      int cnt = 0;
      int d = 0;
      int count_if = 0;
      int flags[100];
    
      int mem_smp[100];
      char copy_buf_data[150][150] = {{0}};
      char post_buf[150];
      int count_cmd = 0;
    
      int sign_ch;
      FILE *file_buf;
    
      char *buffer = 0;
      char *intro_buffer = 0;
      int save_left_side = 0, save_exp = 0;
      int goto_flag = 0;
    
      int count_table_intro = 0;
      int count_table_extra = 0;
      char name_file[100];
    
      char buffer_postfix[150];
      char buf_data[150][150] = {{0}};
      int val_if[3] = {0};
    
      int data_if[150] = {0};
    
     data_if[60] = 4100;
     data_if[61] = 1;

    Симплтрон из задачи по Дейтелам
    1

    gne4do, 02 Октября 2023

    Комментарии (1)
  10. Ruby / Говнокод #28860

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    class MoveAchieveTemplateIdentifierToRatePeriodPrograms < ActiveRecord::Migration
      def up
        RatePeriod.find_in_batches(batch_size: 1_000) do |batch|
          sleep(50)
          batch.each do |rate_period|
            achieve_template_identifier = rate_period.achieve_template_identifier
            rate_period.rate_period_programs.update_all(achieve_template_identifier: achieve_template_identifier)
          end
        end
      end
    
      def down
        raise ActiveRecord::IrreversibleMigration
      end
    end

    fml

    Shannarra_, 02 Октября 2023

    Комментарии (0)