質問編集履歴
2
問題内容の追加
    
        title	
    CHANGED
    
    | 
            File without changes
         | 
    
        body	
    CHANGED
    
    | @@ -2,12 +2,13 @@ | |
| 2 2 |  | 
| 3 3 | 
             
            c言語を用いてtexの数式モードであらわされたものをhtmlの数式に変換するというプログラムを作成しています
         | 
| 4 4 | 
             
            条件はギリシャ文字と上付き、下付き文字の変換ですなぜうまくいかないのでしょうか。
         | 
| 5 | 
            +
            また、この機能を実現したいとき、どのようなコードを書けばよいのでしょうか
         | 
| 5 6 |  | 
| 6 7 |  | 
| 7 8 | 
             
            ### 発生している問題・エラーメッセージ
         | 
| 8 9 |  | 
| 9 10 | 
             
            ```
         | 
| 10 | 
            -
            \alpha x_1とコマンドラインで実行すると &alpha x<sub>1</sub>と出力してほしいが alpha x_1という出力結果になる
         | 
| 11 | 
            +
            \alpha x_1とコマンドラインで実行すると &alpha x<sub>1</sub>と出力してほしいが alpha x_1という出力結果になる そもそもこのコードは欠陥が多い気がします
         | 
| 11 12 | 
             
            ```
         | 
| 12 13 |  | 
| 13 14 | 
             
            ### 該当のソースコード
         | 
1
コードの見易さの改善、具体的な例の追加
    
        title	
    CHANGED
    
    | 
            File without changes
         | 
    
        body	
    CHANGED
    
    | @@ -7,7 +7,7 @@ | |
| 7 7 | 
             
            ### 発生している問題・エラーメッセージ
         | 
| 8 8 |  | 
| 9 9 | 
             
            ```
         | 
| 10 | 
            -
             | 
| 10 | 
            +
            \alpha x_1とコマンドラインで実行すると &alpha x<sub>1</sub>と出力してほしいが alpha x_1という出力結果になる
         | 
| 11 11 | 
             
            ```
         | 
| 12 12 |  | 
| 13 13 | 
             
            ### 該当のソースコード
         | 
| @@ -20,157 +20,147 @@ | |
| 20 20 | 
             
            void get_Subscript(char *arg);
         | 
| 21 21 | 
             
            void get_Superscript(char *arg);
         | 
| 22 22 |  | 
| 23 | 
            +
            int main(int argc, char *argv[]) {
         | 
| 24 | 
            +
            	if (argc > 9) {
         | 
| 25 | 
            +
            		printf("Illegal number of argument.\n");
         | 
| 26 | 
            +
            		return (-1);
         | 
| 27 | 
            +
            	}
         | 
| 28 | 
            +
            	int k, a;
         | 
| 23 29 |  | 
| 24 | 
            -
             | 
| 30 | 
            +
            	for (k = 1; k < argc; k++) {
         | 
| 25 | 
            -
            {
         | 
| 26 | 
            -
                if(argc>9) {
         | 
| 27 | 
            -
                        printf("Illegal number of argument.\n");
         | 
| 28 | 
            -
                        return(-1);
         | 
| 29 | 
            -
                    }
         | 
| 30 | 
            -
                int k,a;
         | 
| 31 31 |  | 
| 32 | 
            +
            		get_Greek_Mathsymbol(argv[k]);
         | 
| 33 | 
            +
            		get_Lgreek(argv[k]);
         | 
| 32 | 
            -
             | 
| 34 | 
            +
            		get_Subscript(argv[k]);
         | 
| 35 | 
            +
            		get_Superscript(argv[k]);
         | 
| 33 36 |  | 
| 34 | 
            -
                    get_Greek_Mathsymbol(argv[k]);
         | 
| 35 | 
            -
             | 
| 37 | 
            +
            	}
         | 
| 36 | 
            -
                    get_Subscript(argv[k]);
         | 
| 37 | 
            -
                    get_Superscript(argv[k]);
         | 
| 38 38 |  | 
| 39 | 
            +
            	for (a = 1; a <= argc; a++) {
         | 
| 40 | 
            +
            		printf("%s\n", argv[a]);
         | 
| 39 | 
            -
             | 
| 41 | 
            +
            	}
         | 
| 40 | 
            -
             | 
| 41 | 
            -
             | 
| 42 | 
            +
            	return 0;
         | 
| 42 | 
            -
            printf("%s\n", argv[a]);
         | 
| 43 43 | 
             
            }
         | 
| 44 | 
            -
            return 0;
         | 
| 45 | 
            -
            }
         | 
| 46 44 |  | 
| 47 | 
            -
            void get_Greek_Mathsymbol(char *arg){
         | 
| 45 | 
            +
            void get_Greek_Mathsymbol(char *arg) {
         | 
| 48 46 |  | 
| 49 | 
            -
            char greek[][10] = {"alpha", "beta", "gamma", "delta", "epsilon", "zeta", | 
| 47 | 
            +
            	char greek[][10] = { "alpha", "beta", "gamma", "delta", "epsilon", "zeta",
         | 
| 48 | 
            +
            			"eta", "theta", "iota", "kappa", "lambda", "mu", "nu", "xi", "pi",
         | 
| 49 | 
            +
            			"rho", "sigma", "tau", "upsilon", "phi", "chi", "psi", "omega",
         | 
| 50 | 
            +
            			"Gamma", "Delta", "Theta", "Lambda", "Xi", "Pi", "Sigma", "Upsilon",
         | 
| 51 | 
            +
            			"Phi", "Psi", "Omega" "geq", "leq" };
         | 
| 50 52 |  | 
| 51 | 
            -
            static int Cnt1 = 0;
         | 
| 53 | 
            +
            	static int Cnt1 = 0;
         | 
| 52 | 
            -
            int cnt1 = 0;
         | 
| 54 | 
            +
            	int cnt1 = 0;
         | 
| 53 55 |  | 
| 54 | 
            -
            if(*arg == '\' | 
| 56 | 
            +
            	if (*arg == '\') {
         | 
| 55 | 
            -
             | 
| 57 | 
            +
            		arg++;
         | 
| 56 | 
            -
            while(*arg != '\0'){   // これをすべての文字についてループ
         | 
| 58 | 
            +
            		while (*arg != '\0') {   // これをすべての文字についてループ
         | 
| 57 59 |  | 
| 60 | 
            +
            			if (*arg != greek[Cnt1][cnt1]) {
         | 
| 61 | 
            +
            				break;
         | 
| 62 | 
            +
            			} else if ((*(arg + 1) == '\0') || (*(arg + 1) == '_')
         | 
| 63 | 
            +
            					|| (*(arg + 1) == '^')) {
         | 
| 64 | 
            +
            				*(arg - cnt1 - 1) = '&';
         | 
| 65 | 
            +
            				if (*arg == 'q') {
         | 
| 66 | 
            +
            					*arg = '\0';
         | 
| 67 | 
            +
            				}
         | 
| 68 | 
            +
            			}
         | 
| 58 69 |  | 
| 70 | 
            +
            			else {
         | 
| 59 | 
            -
             | 
| 71 | 
            +
            				arg++, cnt1++;
         | 
| 60 | 
            -
             | 
| 72 | 
            +
            				continue;
         | 
| 61 | 
            -
            }
         | 
| 73 | 
            +
            			}
         | 
| 62 | 
            -
            else if((*(arg+1) == '\0') || (*(arg+1) == '_') || (*(arg+1) == '^')){
         | 
| 63 | 
            -
             *(arg-cnt1-1) = '&';
         | 
| 64 | 
            -
             if(*arg == 'q'){
         | 
| 65 | 
            -
                 *arg = '\0';
         | 
| 66 | 
            -
             }
         | 
| 67 | 
            -
            }
         | 
| 68 74 |  | 
| 69 | 
            -
            else{
         | 
| 70 | 
            -
                arg++, cnt1++;
         | 
| 71 | 
            -
                continue;
         | 
| 72 | 
            -
            }
         | 
| 75 | 
            +
            		}
         | 
| 73 76 |  | 
| 77 | 
            +
            	}
         | 
| 78 | 
            +
            	Cnt1++;
         | 
| 74 79 | 
             
            }
         | 
| 75 80 |  | 
| 76 | 
            -
            }
         | 
| 77 | 
            -
             | 
| 81 | 
            +
            void get_Lgreek(char *arg) {
         | 
| 78 | 
            -
            }
         | 
| 79 82 |  | 
| 83 | 
            +
            	char Greek[][10] = { "Alpha", "Beta", "Gamma", "Epsilon", "Zeta", "Eta",
         | 
| 84 | 
            +
            			"Iota", "Kappa", "Mu", "Nu", "Rho", "Tau", "Chi", "omicron" };
         | 
| 80 | 
            -
             | 
| 85 | 
            +
            	static int Cnt2 = 0;
         | 
| 86 | 
            +
            	int i = 0;
         | 
| 81 87 |  | 
| 82 | 
            -
            char Greek[][10] = {"Alpha", "Beta", "Gamma", "Epsilon", "Zeta", "Eta", "Iota", "Kappa", "Mu", "Nu", "Rho", "Tau", "Chi", "omicron"};
         | 
| 83 | 
            -
             | 
| 88 | 
            +
            	if ((*arg == Greek[Cnt2][0])
         | 
| 84 | 
            -
            int i = 0;
         | 
| 85 | 
            -
             | 
| 86 | 
            -
             | 
| 89 | 
            +
            			&& ((*(arg + 1) == '\0') || (*(arg + 1) == '_')
         | 
| 90 | 
            +
            					|| (*(arg + 1) == '^'))) {
         | 
| 87 | 
            -
             | 
| 91 | 
            +
            		*arg = '&';
         | 
| 88 | 
            -
             | 
| 92 | 
            +
            		arg++;
         | 
| 89 | 
            -
            while(Greek[Cnt2][i] != '\0'){
         | 
| 93 | 
            +
            		while (Greek[Cnt2][i] != '\0') {
         | 
| 90 | 
            -
             | 
| 94 | 
            +
            			*arg = Greek[Cnt2][i];
         | 
| 91 | 
            -
             | 
| 95 | 
            +
            			arg++, i++;
         | 
| 92 | 
            -
             | 
| 96 | 
            +
            		}
         | 
| 97 | 
            +
            	}
         | 
| 98 | 
            +
            	Cnt2++;
         | 
| 93 99 | 
             
            }
         | 
| 94 | 
            -
            Cnt2++;
         | 
| 95 | 
            -
            }
         | 
| 96 100 |  | 
| 101 | 
            +
            void get_Subscript(char *arg) {
         | 
| 102 | 
            +
            	char rest1[10];
         | 
| 103 | 
            +
            	int i, j, l, m;
         | 
| 104 | 
            +
            	int cnt2 = 0;
         | 
| 105 | 
            +
            	char subscript[][10] = { "<sub>", "</sub>" };
         | 
| 97 106 |  | 
| 107 | 
            +
            	if (*arg == '_') {
         | 
| 108 | 
            +
            		arg++;
         | 
| 109 | 
            +
            		for (i = 0; i <= 9; i++) {
         | 
| 98 110 |  | 
| 111 | 
            +
            			if ((*arg == '\0') || (*arg == '^')) {
         | 
| 112 | 
            +
            				break;
         | 
| 113 | 
            +
            			}
         | 
| 114 | 
            +
            			rest1[i] = *arg;
         | 
| 115 | 
            +
            			arg++, cnt2++;
         | 
| 116 | 
            +
            		}
         | 
| 99 117 |  | 
| 118 | 
            +
            		for (j = 0; subscript[0][j] != '\0'; j++) {
         | 
| 119 | 
            +
            			*(arg - cnt2 - 1 + j) = subscript[0][j];
         | 
| 120 | 
            +
            		}
         | 
| 121 | 
            +
            		for (l = 0; l < cnt2; l++) {
         | 
| 122 | 
            +
            			*(arg - cnt2 + 4 + l) = rest1[l];
         | 
| 123 | 
            +
            		}
         | 
| 124 | 
            +
            		for (m = 0; subscript[1][m] != '\0'; m++) {
         | 
| 125 | 
            +
            			*(arg + 4 + m) = subscript[1][m];
         | 
| 126 | 
            +
            		}
         | 
| 127 | 
            +
            	} else {
         | 
| 128 | 
            +
            		arg++;
         | 
| 129 | 
            +
            	}
         | 
| 100 130 |  | 
| 131 | 
            +
            }
         | 
| 101 132 |  | 
| 133 | 
            +
            void get_Superscript(char *arg) {
         | 
| 134 | 
            +
            	char rest2[10];
         | 
| 135 | 
            +
            	int i, j, l, m;
         | 
| 136 | 
            +
            	int cnt3 = 0;
         | 
| 137 | 
            +
            	char *superscript[] = { "<sup>", "</sup>" };
         | 
| 138 | 
            +
            	if (*arg == '_') {
         | 
| 139 | 
            +
            		arg++;
         | 
| 140 | 
            +
            		for (i = 0; i <= 9; i++) {
         | 
| 102 141 |  | 
| 142 | 
            +
            			if (*arg == '\0') {
         | 
| 143 | 
            +
            				break;
         | 
| 144 | 
            +
            			}
         | 
| 145 | 
            +
            			rest2[i] = *arg;
         | 
| 146 | 
            +
            			arg++, cnt3++;
         | 
| 147 | 
            +
            		}
         | 
| 103 148 |  | 
| 149 | 
            +
            		for (j = 0; superscript[0][j] != '\0'; j++) {
         | 
| 150 | 
            +
            			*(arg - cnt3 - 1 + j) = superscript[0][j];
         | 
| 151 | 
            +
            		}
         | 
| 104 | 
            -
             | 
| 152 | 
            +
            		for (l = 0; l < cnt3; l++) {
         | 
| 105 | 
            -
             | 
| 153 | 
            +
            			*(arg - cnt3 + 4 + l) = rest2[l];
         | 
| 106 | 
            -
                int i, j, l, m;
         | 
| 107 | 
            -
             | 
| 154 | 
            +
            		}
         | 
| 108 | 
            -
             | 
| 155 | 
            +
            		for (m = 0; superscript[1][m] != '\0'; m++) {
         | 
| 156 | 
            +
            			*(arg + 4 + m) = superscript[1][m];
         | 
| 109 157 |  | 
| 158 | 
            +
            		}
         | 
| 110 | 
            -
             | 
| 159 | 
            +
            	} else {
         | 
| 111 | 
            -
             | 
| 160 | 
            +
            		arg++;
         | 
| 112 | 
            -
                    for(i=0; i<=9; i++){
         | 
| 113 | 
            -
             | 
| 114 | 
            -
                    if((*arg == '\0') || (*arg == '^')){
         | 
| 115 | 
            -
                        break;
         | 
| 116 | 
            -
             | 
| 161 | 
            +
            	}
         | 
| 117 | 
            -
                    rest1[i] = *arg;
         | 
| 118 | 
            -
                    arg++, cnt2++;
         | 
| 119 | 
            -
                }
         | 
| 120 | 
            -
             | 
| 121 | 
            -
             | 
| 122 | 
            -
             | 
| 123 | 
            -
            for(j=0; subscript[0][j] != '\0'; j++){
         | 
| 124 | 
            -
            *(arg-cnt2-1+j) = subscript[0][j];
         | 
| 125 162 | 
             
            }
         | 
| 126 | 
            -
            for(l=0; l<cnt2; l++){
         | 
| 127 | 
            -
            *(arg-cnt2+4+l) = rest1[l];
         | 
| 128 | 
            -
            }
         | 
| 129 | 
            -
            for(m=0; subscript[1][m] != '\0'; m++){
         | 
| 130 | 
            -
            *(arg+4+m) =     subscript[1][m];
         | 
| 131 | 
            -
            }
         | 
| 132 | 
            -
                }
         | 
| 133 | 
            -
            else{
         | 
| 134 | 
            -
                    arg++;
         | 
| 135 | 
            -
                }
         | 
| 136 163 |  | 
| 137 | 
            -
             | 
| 138 | 
            -
             | 
| 139 | 
            -
                }
         | 
| 140 | 
            -
             | 
| 141 | 
            -
            void get_Superscript(char *arg){
         | 
| 142 | 
            -
                char rest2[10] ;
         | 
| 143 | 
            -
                 int i, j, l, m;
         | 
| 144 | 
            -
                 int cnt3 = 0;
         | 
| 145 | 
            -
                 char *superscript[] = {"<sup>", "</sup>"};
         | 
| 146 | 
            -
                    if(*arg == '_'){
         | 
| 147 | 
            -
                        arg++;
         | 
| 148 | 
            -
                    for(i=0; i<=9; i++){
         | 
| 149 | 
            -
             | 
| 150 | 
            -
                    if(*arg == '\0'){
         | 
| 151 | 
            -
                        break;
         | 
| 152 | 
            -
                        }
         | 
| 153 | 
            -
                        rest2[i] = *arg;
         | 
| 154 | 
            -
                        arg++, cnt3++;
         | 
| 155 | 
            -
                    }
         | 
| 156 | 
            -
             | 
| 157 | 
            -
             | 
| 158 | 
            -
             | 
| 159 | 
            -
                for(j=0; superscript[0][j] != '\0'; j++){
         | 
| 160 | 
            -
                *(arg-cnt3-1+j) = superscript[0][j];
         | 
| 161 | 
            -
                }
         | 
| 162 | 
            -
                for(l=0; l<cnt3; l++){
         | 
| 163 | 
            -
                *(arg-cnt3+4+l) = rest2[l];
         | 
| 164 | 
            -
                }
         | 
| 165 | 
            -
                for(m=0; superscript[1][m] != '\0'; m++){
         | 
| 166 | 
            -
                *(arg+4+m) =     superscript[1][m];
         | 
| 167 | 
            -
             | 
| 168 | 
            -
                }
         | 
| 169 | 
            -
                    }
         | 
| 170 | 
            -
                else{
         | 
| 171 | 
            -
                            arg++;
         | 
| 172 | 
            -
                        }
         | 
| 173 | 
            -
            }
         | 
| 174 164 | 
             
            ```
         | 
| 175 165 |  | 
| 176 166 | 
             
            ### 試したこと
         | 
