Révision 136 pobysoC-4.0/src/pobyso.c
| pobyso.c (revision 136) | ||
|---|---|---|
| 136 | 136 |
{
|
| 137 | 137 |
int expressionLength, i; |
| 138 | 138 |
char *expressionWithSemiCo; |
| 139 |
sollya_obj_t expressionSa;
|
|
| 139 |
sollya_obj_t expressionSo;
|
|
| 140 | 140 |
|
| 141 | 141 |
/* Arguments check. */ |
| 142 | 142 |
if (expression == NULL) |
| ... | ... | |
| 166 | 166 |
if (expression[i] == ';') /* Nothing special to do: |
| 167 | 167 |
try to parse the string*/ |
| 168 | 168 |
{
|
| 169 |
expressionSa = sollya_lib_parse_string(expression); |
|
| 170 |
return expressionSa; |
|
| 169 |
expressionSo = sollya_lib_parse_string(expression); |
|
| 170 |
if (sollya_lib_obj_is_error(expressionSo)) |
|
| 171 |
{
|
|
| 172 |
sollya_lib_clear_obj(expressionSo); |
|
| 173 |
return NULL; |
|
| 174 |
} |
|
| 175 |
else |
|
| 176 |
{
|
|
| 177 |
return expressionSo; |
|
| 178 |
} |
|
| 171 | 179 |
} |
| 172 | 180 |
else |
| 173 | 181 |
{
|
| ... | ... | |
| 191 | 199 |
strncpy(expressionWithSemiCo, expression, i+1); |
| 192 | 200 |
expressionWithSemiCo[i + 1] = ';'; |
| 193 | 201 |
expressionWithSemiCo[i + 2] = '\0'; |
| 194 |
expressionSa = sollya_lib_parse_string(expressionWithSemiCo);
|
|
| 202 |
expressionSo = sollya_lib_parse_string(expressionWithSemiCo);
|
|
| 195 | 203 |
free(expressionWithSemiCo); |
| 196 |
return expressionSa; |
|
| 204 |
if (sollya_lib_obj_is_error(expressionSo)) |
|
| 205 |
{
|
|
| 206 |
sollya_lib_clear_obj(expressionSo); |
|
| 207 |
return NULL; |
|
| 208 |
} |
|
| 209 |
else |
|
| 210 |
{
|
|
| 211 |
return expressionSo; |
|
| 212 |
} |
|
| 197 | 213 |
} /* End character != ';' and from a blank. */ |
| 198 | 214 |
/* Create a new string for the expression, add the ";" and |
| 199 | 215 |
* and call sollya_lib_parse_string. */ |
| ... | ... | |
| 206 | 222 |
"ONLY_BLANK_ARGUMENT", |
| 207 | 223 |
"The expression is only made of blanks"); |
| 208 | 224 |
return NULL; |
| 209 |
|
|
| 210 | 225 |
} /* pobyso_parse_string */ |
| 211 | 226 |
|
| 212 | 227 |
pobyso_func_exp_t |
| ... | ... | |
| 295 | 310 |
* @see pobyso.h#pobyso_subpoly |
| 296 | 311 |
*/ |
| 297 | 312 |
pobyso_func_exp_t |
| 298 |
pobyso_subpoly(pobyso_func_exp_t polynomialSo, long expsNum,...)
|
|
| 313 |
pobyso_subpoly(pobyso_func_exp_t polynomialSo, long expsNum, long int* expsList)
|
|
| 299 | 314 |
{
|
| 300 |
sollya_obj_t expsListSo = NULL; |
|
| 301 |
sollya_obj_t* expsList = NULL; |
|
| 302 |
sollya_obj_t subpoly = NULL; |
|
| 315 |
sollya_obj_t expsListSo = NULL; |
|
| 316 |
sollya_obj_t* expsList_pso = NULL; |
|
| 317 |
sollya_obj_t subpoly = NULL; |
|
| 318 |
int i, j; |
|
| 303 | 319 |
|
| 304 |
va_list vaExpsList; |
|
| 305 |
int currentExp; |
|
| 306 |
int i; |
|
| 307 |
|
|
| 308 | 320 |
/* Arguments check. */ |
| 309 | 321 |
if (polynomialSo == NULL) return NULL; |
| 310 | 322 |
if (expsNum < 0) return NULL; |
| 311 | 323 |
if (expsNum == 0) return sollya_lib_copy_obj(polynomialSo); |
| 312 |
|
|
| 313 |
va_start(vaExpsList, expsNum);
|
|
| 314 |
expsList = (sollya_obj_t*) malloc(expsNum * sizeof(sollya_obj_t)); |
|
| 315 |
if (expsList == NULL) |
|
| 324 |
if (expsList == 0) return NULL; |
|
| 325 |
/* Create a list of Sollya constants. */
|
|
| 326 |
expsList_pso = (sollya_obj_t*) malloc(expsNum * sizeof(sollya_obj_t));
|
|
| 327 |
if (expsList_pso == NULL)
|
|
| 316 | 328 |
{
|
| 317 | 329 |
pobyso_error_message("pobyso_subpoly",
|
| 318 | 330 |
"MEMORY_ALLOCATION_ERROR", |
| 319 |
"Could not allocate the expression string");
|
|
| 331 |
"Could not allocate the Sollya exponents list");
|
|
| 320 | 332 |
return NULL; |
| 321 | 333 |
} |
| 334 |
/* Fill up the list. */ |
|
| 322 | 335 |
for (i = 0 ; i < expsNum ; i++) |
| 323 | 336 |
{
|
| 324 |
currentExp = va_arg(vaExpsList, long); |
|
| 325 |
expsList[i] = sollya_lib_constant_from_int64(currentExp); |
|
| 337 |
/* Abort if an exponent is negative. */ |
|
| 338 |
if (expsList[i] < 0 ) |
|
| 339 |
{
|
|
| 340 |
for (j = 0 ; j < i ; j++) |
|
| 341 |
{
|
|
| 342 |
sollya_lib_clear_obj(expsList_pso[j]); |
|
| 343 |
} |
|
| 344 |
free(expsList_pso); |
|
| 345 |
return NULL; |
|
| 346 |
} |
|
| 347 |
expsList_pso[i] = sollya_lib_constant_from_int64(expsList[i]); |
|
| 326 | 348 |
} /* End for */ |
| 327 |
va_end(vaExpsList); |
|
| 328 |
expsListSo = sollya_lib_list(expsList, expsNum); |
|
| 329 |
if (expsList == NULL) |
|
| 349 |
expsListSo = sollya_lib_list(expsList_pso, expsNum); |
|
| 350 |
for (i = 0 ; i < expsNum ; i++) |
|
| 330 | 351 |
{
|
| 352 |
sollya_lib_clear_obj(expsList_pso[i]); |
|
| 353 |
} |
|
| 354 |
free(expsList_pso); |
|
| 355 |
if (expsListSo == NULL) |
|
| 356 |
{
|
|
| 331 | 357 |
pobyso_error_message("pobyso_subpoly",
|
| 332 | 358 |
"LIST_CREATIONERROR", |
| 333 | 359 |
"Could not create the exponents list"); |
| 334 |
for (i = 0 ; i < expsNum ; i++) |
|
| 335 |
{
|
|
| 336 |
sollya_lib_clear_obj(expsList[i]); |
|
| 337 |
} |
|
| 338 |
free(expsList); |
|
| 339 | 360 |
return NULL; |
| 340 | 361 |
} |
| 341 | 362 |
subpoly = sollya_lib_subpoly(polynomialSo, expsListSo); |
| 363 |
pobyso_autoprint(expsListSo); |
|
| 342 | 364 |
sollya_lib_clear_obj(expsListSo); |
| 343 |
for (i = 0 ; i < expsNum ; i++) |
|
| 344 |
{
|
|
| 345 |
sollya_lib_clear_obj(expsList[i]); |
|
| 346 |
} |
|
| 347 |
free(expsList); |
|
| 348 | 365 |
return subpoly; |
| 349 | 366 |
} /* pobyso_subpoly. */ |
| 350 | 367 |
|
Formats disponibles : Unified diff