Skip to content
Snippets Groups Projects
Commit 8405fb8f authored by orestis.malaspin's avatar orestis.malaspin
Browse files

adding all the files from old repo

parent aea485c7
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
.gitignore 0 → 100644
+ 2
− 0
View file @ 8405fb8f
*.pdf
*.html
Makefile 0 → 100644
+ 18
− 0
View file @ 8405fb8f
OPTIONS = --filter=pandoc-numbering
OPTIONS += --filter=pandoc-crossref
PDFOPTIONS = --highlight-style my_highlight.theme
PDFOPTIONS += --pdf-engine pdflatex
PDFOPTIONS += --number-sections
PDFOPTIONS += --template=./default.latex
all: base_1.pdf intro.pdf
intro.pdf: intro.md *.theme
pandoc -t beamer -o $@ $<
base_1.pdf: base_1.md *.theme
pandoc -t beamer -o $@ $<
clean:
rm -f *.pdf
base_1.md 0 → 100644
+ 593
− 0
View file @ 8405fb8f
% Programmation séquentielle en C
% Base I - Inspirés des slides de F. Glück
% 18 septembre 2019
# Historique (1/2)
- Conçu initialement pour la programmation des systèmes d’exploitation (UNIX).
- Créé par Dennis Ritchie à Bell Labs en 1972 dans la continuation de CPL, BCPL et B.
- Standardisé entre 1983 et 1988 (ANSI C).
- La syntaxe de C est devenue la base d’autres langages comme C++, Objective-C, Java, Go, C#, Rust, etc.
- Révisions plus récentes, notamment C99, C11, puis C18.
# Historique (2/2)
- Développement de C lié au développement d’UNIX.
- UNIX a été initialement développé en assembleur:
- Les instructions assembleur sont de très bas niveau
- Les instructions assembleur sont spécifiques à l’architecture du processeur.
- Pour rendre UNIX portable, un langage de *haut niveau* (en 1972) était nécessaire.
- Comparé à l’assembleur, le C est :
- Un langage de "haut niveau": C offre des fonctions, des structures de données, des constructions de contrôle de flots (`while`{.C}, `for`{.C}, etc).
- Portable: un programme C peut être exécuté sur un *très grand nombre* de plateformes (il suffit de recompiler le *même code* pour l’architecture voulue).
# Qu'est-ce que le C?
- "Petit langage simple" (en 2019).
- Langage compilé, statiquement (et faiblement) typé, procédural, portable, très efficace.
- Langage "bas niveau" (en 2019): management explicite et manuelle de la mémoire (allocation/désallocation), grande liberté pour sa manipulation.
- Pas de structures de haut niveau: chaînes de caractères, vecteurs dynamiques, listes, ...
- Aucune validation ou presque sur la mémoire (pointeurs, overflows, ...).
# Exemple de programme
```C
#include <stdio.h>
#include <stdlib.h>
int main() {
printf("Enter n: "); // affichage
int n = 0; // déclaration et initialisation de n
scanf("%d", &n); // entrée au clavier
int sum = 0; // déclaration et initialisation de sum
for (int i = 0; i <= n; ++i) { // boucle
sum += i;
}
printf("Sum of the %d first integers: %d\n", n, sum);
if (sum != n * (n+1) / 2) { // branchement cond.
printf("Error: the answer is wrong.\n");
return EXIT_FAILURE; // code d'erreur
}
return EXIT_SUCCESS; // code de réussite
}
```
# Génération d'un exécutable
- Pour pouvoir être exécuté un code C doit être d'abord compilé (avec `gcc` ou `clang`).
- Pour un code `prog.c` la compilation "minimale" est
```bash
$ clang prog.c
$ ./a.out # exécutable par défaut
```
- Il existe une multitude d'options de compilation:
1. `-std=c11` utilisation de C11.
2. `-Wall et -Wextra` activation des warnings.
3. `-fsanitize=…` contrôles d’erreurs extensifs à l’exécution (au prix d’un coût en performance).
Sur Ubuntu 14.04 `-fsanitize=leak` et `-fsanitize=undefined` ne sont pas supportés (`cat /etc/lsb-release` indique la version).
4. `-g` symboles de débogages sont gardés.
5. `-o` défini le fichier exécutable à produire en sortie.
<!-- 6. `-O1`, `-O2`, `-O3`: activation de divers degrés d'optimisation -->
```bash
$ clang -std=c11 -Wall -Wextra -g porg.c -o prog
-fsanitize=address -fsanitize=leak -fsanitize=undefined
```
# La simplicité de C?
- 32 mots-clé et c'est tout
---------------- -------------- ---------------- ---------------
`auto`{.C} `double`{.C} `int`{.C} `struct`{.C}
`break`{.C} `else`{.C} `long`{.C} `switch`{.C}
`case`{.C} `enum`{.C} `register`{.C} `typedef`{.C}
`char`{.C} `extern`{.C} `return`{.C} `union`{.C}
`const`{.C} `float`{.C} `short`{.C} `unsigned`{.C}
`continue`{.C} `for`{.C} `signed`{.C} `void`{.C}
`default`{.C} `goto`{.C} `sizeof`{.C} `volatile`{.C}
`do`{.C} `if`{.C} `static`{.C} `while`{.C}
---------------- -------------- ---------------- ---------------
# Déclaration et typage
En C lorsqu'on veut utiliser une variable (ou une constante), on doit déclarer son type
```C
const double two = 2.0; // déclaration et init.
int x; // déclaration (instruction)
char c; // déclaration (instruction)
x = 1; // affectation (expression)
c = 'a'; // affectation (expression)
int y = x; // déclaration et initialisation en même temps
int a, b, c; // déclarations multiples
int d = e = f = 1; // décl./init. multiples
```
# Types de base (1/N)
## Numériques
Type Signification (**gcc pour x86-64**)
---------------------------------- ---------------------------------------------
`char`{.C}, `unsigned char`{.C} Entier signé/non-signé 8-bit
`short`{.C}, `unsigned short`{.C} Entier signé/non-signé 16-bit
`int`{.C}, `unsigned int`{.C} Entier signé/non-signé 32-bit
`long`{.C}, `unsigned long`{.C} Entier signé/non-signé 64-bit
`float`{.C} Nombre à virgule flottante, simple précision
`double`{.C} Nombre à virgule flottante, double précision
---------------------------------- ---------------------------------------------
**La signification de `short`{.C}, `int`{.C}, ... dépend du compilateur et de l'architecture.**
# Types de base (2/N)
Voir `<stdint.h>` pour des représentations **portables**
Type Signification
---------------------------------- ---------------------------------------------
`int8_t`{.C}, `uint8_t`{.C} Entier signé/non-signé 8-bit
`int16_t`{.C}, `uint16_t`{.C} Entier signé/non-signé 16-bit
`int32_t`{.C}, `uint32_t`{.C} Entier signé/non-signé 32-bit
`int64_t`{.C}, `uint64_t`{.C} Entier signé/non-signé 64-bit
---------------------------------- ---------------------------------------------
# Types de base (3/N)
## Booléens
- Le ANSI C n'offre pas de booléens.
- L'entier `0`{.C} signifie *faux*, tout le reste *vrai*.
- Depuis C99, la librairie `stdbool` met à disposition un type `bool`{.C}.
- En réalité c'est un entier:
- $1 \Rightarrow$ `true`{.C}
- $0 \Rightarrow$ `false`{.C}
<!-- TODO Quiz en ligne -->
<!-- ```C
if (42) { /* vrai */ }
int x = 100;
if (x == 4) { /* faux */ }
if (x) { /* vrai */ }
while (x−−) { /* répète tant que x est différent de 0 */ }
if (0) { /* faux */ }
if (i = 4) { /* vrai */ }
if (i = 0) { /* faux */ }
#include <stdbool.h>
bool x = true;
if (x) { /* vrai */ }
``` -->
# Types de base (4/N)
## Conversions
- Les conversions se font de manière:
- Explicite:
```C
int a = (int)2.8;
double b = (double)a;
int c = (int)(2.8+0.5);
```
- Implicite:
```C
int a = 2.8; // warning, si activés, avec clang
double b = a + 0.5;
char c = b; // pas de warning...
int d = 'c';
```
<!-- TODO Quiz en ligne -->
<!-- ```C
int a = (int)2.8; // 2
double b = 2.85;
int c = b + 0.5; // 3
int d = a + 0.5; // 2
bool d = 2.78; // 0
bool e = 1.0; // 1
``` -->
# Expressions et opérateurs (1/N)
Une expression est tout bout de code qui est **évalué**.
## Expressions simples
- Pas d'opérateurs impliqués.
- Les littéraux, les variables, et les constantes.
```C
const int L = -1; // 'L' est une constante, -1 un littéral
int x = 0; // '0' est un litéral
int y = x; // 'x' est une variable
int z = L; // 'L' est une constante
```
## Expressions complexes
- Obtenues en combinant des *opérandes* avec des *opérateurs*
```C
int x; // pas une expression (une instruction)
x = 4 + 5; // 4 + 5 est une expression
// dont le résultat est affecté à 'x'
```
# Expressions et opérateurs (1/N)
## Opérateurs relationnels
Opérateurs testant la relation entre deux *expressions*:
- `(a opérateur b)` retourne `1`{.C} si l'expression s'évalue à `true`{.C}, `0`{.C} si l'expression s'évalue à `false`{.C}.
| Opérateur | Syntaxe | Résultat |
|-----------|--------------|----------------------|
| `<`{.C} | `a < b`{.C} | 1 si a < b; 0 sinon |
| `>`{.C} | `a > b`{.C} | 1 si a > b; 0 sinon |
| `<=`{.C} | `a <= b`{.C} | 1 si a <= b; 0 sinon |
| `>=`{.C} | `a >= b`{.C} | 1 si a >= b; 0 sinon |
| `==`{.C} | `a == b`{.C} | 1 si a == b; 0 sinon |
| `!=`{.C} | `a != b`{.C} | 1 si a != b; 0 sinon |
# Opérateurs (2/N)
## Opérateurs logiques
| Opérateur | Syntaxe | Signification |
|-----------|--------------|----------------------|
| `&&`{.C} | `a && b`{.C} | ET logique |
| `||`{.C} | `a || b`{.C} | OU logique |
| `!`{.C} | `!a`{.C} | NON logique |
<!-- TODO: Quiz -->
<!-- ```C
1 && 0 == 0
7 && 3 == 1
4 || 3 == 1
!34 == 0
!0 == 1
Soit n un unsigned char initialisé à 127:
!n == 0
``` -->
# Opérateurs (3/N)
## Opérateurs arithmétiques
| Opérateur | Syntaxe | Signification |
|-----------|--------------|----------------------|
| `+`{.C} | `a + b`{.C} | Addition |
| `-`{.C} | `a - b`{.C} | Soustraction |
| `*`{.C} | `a * b`{.C} | Multiplication |
| `/`{.C} | `a / b`{.C} | Division |
| `%`{.C} | `a % b`{.C} | Modulo |
# Opérateurs (4/N)
## Opérateurs d'assignation
| Opérateur | Syntaxe | Signification |
|-----------|--------------|---------------------------------------------|
| `=`{.C} | `a = b`{.C} | Affecte l'opérande de droite `b` à |
| | | l'opérande de gauche `a` et retourne |
| | | la valeur de `b`. |
| `+=`{.C} | `a += b`{.C} | Additionne la valeur de `b` à `a` et |
| | | assigne le résultat à `a`. |
| `-=`{.C} | `a -= b`{.C} | Soustrait la valeur de `b` à `a` et |
| | | assigne le résultat à `a`. |
| `*=`{.C} | `a *= b`{.C} | Multiplie la valeur de `b` à `a` et |
| | | assigne le résultat à `a`. |
| `/=`{.C} | `a /= b`{.C} | Divise la valeur de `b` à `a` et |
| | | assigne le résultat à `a`. |
| `%=`{.C} | `a %= b`{.C} | Calcule le modulo la valeur de `b` à `a` et |
| | | assigne le résultat à `a`. |
| `++`{.C} | `a++`{.C} | Incrémente la valeur de `a` de 1 et |
| | | retourne le résultat (`a += 1`). |
| `..`{.C} | `a--`{.C} | Décrémente la valeur de `a` de 1 et |
| | | retourne le résultat (`a -= 1`). |
| `++`{.C} | `++a`{.C} | Retourne `a`{.C} et incrémente `a` de 1. |
| `..`{.C} | `--a`{.C} | Retourne `a`{.C} et décrémente `a` de 1. |
# Structures de contrôle: `if`{.C} .. `else if`{.C} .. `else`{.C} (1/N)
## Syntaxe
```C
if (expression) {
instructions;
} else if (expression) { // optionnel
// il peut y en avoir plusieurs
instructions;
} else {
instructions; // optionnel
}
```
```C
if (x) { // si x s'évalue à `vrai`
printf("x s'évalue à vrai.\n);
} else if (y == 8) { // si y vaut 8
printf("y vaut 8.\n);
} else {
printf("Ni l'un ni l'autre.\n);
}
```
# Structures de contrôle: `if`{.C} .. `else if`{.C} .. `else`{.C} (2/N)
## Pièges
```C
int x = y = 3;
if (x = 2)
printf("x = 2 est vrai.\n);
else if (y < 8)
printf("y < 8.\n);
else if (y == 3)
printf("y vaut 3 mais cela ne sera jamais affiché.\n);
else
printf("Ni l'un ni l'autre.\n);
x = -1; // toujours évalué
```
# Structures de contrôle: `switch`{.C} .. `case`{.C} (1/N)
```C
switch (expression) {
case constant-expression:
instructions;
break; // optionnel
case constant-expression:
instructions;
break; // optionnel
// ...
default:
instructions;
}
```
**Que se passe-t-il si `break`{C} est absent?**
# Structures de contrôle: `switch`{.C} .. `case`{.C} (2/N)
```C
int x = 0;
switch (x) {
case 0:
case 1:
printf("0 ou 1\n");
break;
case 2:
printf("2\n");
break;
default:
printf("autre\n");
}
```
**Dangereux, mais c'est un moyen d'avoir un "ou" logique dans un case.**
# Structures de contrôle: `for`{.C}, `while`{.C}, `do ... while`{.C} (1/N)
## La boucle `for`{.C}
```C
for (expression1; expression2; expression3) {
instructions;
}
```
## La boucle `while`{.C}
```C
while (expression) {
instructions;
}
```
## La boucle `do ... while`{.C}
```C
do {
instructions;
} while (expression);
```
# Structures de contrôle: `for`{.C}, `while`{.C}, `do ... while`{.C} (2/N)
## La boucle `for`{.C}
```C
int sum = 0; // syntaxe C99
for (int i = 0; i < 10; i++) {
sum += i;
}
for (int i = 0; i != 1; i = rand() % 4) { // ésotérique
printf("C'est plus ésotérique.\n");
}
```
# Structures de contrôle: `for`{.C}, `while`{.C}, `do ... while`{.C} (3/N)
## La boucle `while`{.C}
```C
int sum = 0, i = 0;
while (i < 10) { // pas assuré·e·s de faire un tour
sum += i;
i += 1;
}
```
## La boucle `do ... while`{.C}
```C
int sum = 0, i = 0;
do { // assuré·e·s de faire un tour
sum += i;
i += 1;
} while (i < 10);
```
# Structures de contrôle: `continue`{.C}, `break`{.C} (4/N)
- `continue`{.C} saute à la prochaine itération d'une boucle.
```C
int i = 0;
while (i < 10) {
if (i == 3) {
continue;
}
printf("%d\n", i);
i += 1;
}
```
- `break`{.C} quitte le bloc itératif courant d'une boucle.
```C
for (int i = 0; i < 10; i++) {
if (i == 3) {
break;
}
printf("%d\n", i);
}
```
# Les variables (1/N)
## Variables et portée
- Une variable est un identifiant, qui peut être liée à une valeur (un expression).
- Une variable a une **portée** qui définit où elle est *visible* (où elle peut être accédée).
- La portée est **globale** ou **locale**.
- Une variable est **globale** est accessible à tout endroit d'un programme et doit être déclarée en dehors de toute fonction.
- Une variable est **locale** lorsqu'elle est déclarée dans un **bloc**, `{...}`{.C}.
- Une variable est dans la portée **après** avoir été déclarée.
# Les variables (2/N)
## Exemple
```C
int bar() { // x, y pas visibles ici, max oui }
int foo() {
int x = 1; // x est locale à foo
{
// x est visible ici, y pas encore
int y = 2;
bar(); // ni x ni y sont visible dans bar()
} // y est détruite à la sortie du bloc
} // x est à la sortie de foo
float max; // variable globale accessible partout
int main() {
int z; // locale, à main
} // z est détruite ici, max aussi
```
<!-- TODO: quiz, compile, compile pas -->
<!-- ```C
int main() {
global = 1;
} // COMPILE PAS
```
```C
int main() {
int global = 1;
{
printf("global = %d", global);
}
} // COMPILE
```
```C
int local;
int main() {
local = 1;
{
printf("local = %d", local);
}
} // COMPILE
```
```C
#include <stdio.h>
int local = 0;
int main() {
int local = -1;
{
int local = 1;
printf("local = %d\n", local);
}
} // COMPILE
``` -->
# Entrées/sorties: `printf()`{.C}
- La fonction `printf()`{.C} permet d'afficher du texte sur le terminal:
```C
int printf(const char *format, ...);
```
- Nombre d'arguments variables.
- `format`{.C} est le texte, ainsi que le format (type) des variables à afficher.
- Les arguments suivants sont les expressions à afficher.
```C
#include <stdio.h>
#include <stdlib.h>
int main() {
printf("Hello world.\n");
int val = 1;
printf("Hello world %d time.\n", val);
printf("%f squared is equal to %f.\n", 2.5, 2.5*2.5);
return EXIT_SUCCESS;
}
```
# Entrées/sorties: `scanf()`{.C}
- La fonction `scanf()`{.C} permet de lire du texte formaté entré au clavier:
```C
int scanf(const char *format, ...);
```
- `format`{.C} est le format des variables à lire (comme `printf()`{.C}).
- Les arguments suivants sont les variables où sont stockées les valeurs lues.
```C
#include <stdio.h>
#include <stdlib.h>
int main() {
printf("Enter 3 numbers: \n");
int i, j, k;
scanf("%d %d %d", &i, &j, &k);
printf("You entered: %d %d %d\n", i, j, k);
return EXIT_SUCCESS;
}
```
\ No newline at end of file
base_2.md 0 → 100644
+ 74
− 0
View file @ 8405fb8f
# Les fonctions (1/N)
- Chaque partie indépendante d'un programme se met dans une fonction.
- Syntaxe:
```C
type identificateur(paramètres) { // variables optionnelles
instructions;
return expression; // type donne le type d'expression
}
```
- Exemple:
```C
int max(int a, int b) {
if (a > b) {
return a;
} else {
return b;
}
}
int main() {
int c = max(4, 5);
}
```
# Les fonctions (2/N)
- Il existe un type `void`{.C}, "sans type", en C.
- Il peut être utilisé pour signifier qu'une fonction ne retourne rien, ou qu'elle n'a pas d'arguments.
- `return`{.C} utilisé pour sortir de la fonction.
- Exemple:
```C
void show_text(void) { // second void optionnel
printf("Aucun argument et pas de retour.\n");
return; // optionnel
}
void show_text_again() { // c'est pareil
printf("Aucun argument et pas de retour.\n");
}
```
# Les fonctions (3/N)
## Prototypes de fonctions
- Le prototype donne la **signature** de la fonction, avant qu'on connaisse son implémentation.
- L'appel d'une fonction doit être fait **après** la déclaration du prototype.
```C
int max(int a, int b); // prototype
int max(int a, int b) { // implémentation
if (a > b) {
return a;
} else {
return b;
}
}
```
# Les fonctions (4/N)
## La fonction `main`
- Point d'entrée du programme.
- Retourne le code d'erreur du programme:
- 0: tout s'est bien passé.
- Pas zéro: problème.
- La valeur de retour peut être lue par le shell qui a exécuté le programme.
- `EXIT_SUCCESS`{.C} et `EXIT_FAILURE`{.C} (de `stdlib.h`) sont des valeurs de retour **portables** de programmes C.
\ No newline at end of file
intro.md 0 → 100644
+ 53
− 0
View file @ 8405fb8f
% Programmation séquentielle en C
% Introduction générale
% 18 septembre 2019
# La hotline
-------------------- ------------------------------ --------------------
Orphée Antoniadis orphee.antoniadis@hesge.ch
Pierre Buffo pierre.buffo@hesge.ch
Pierre Kunzli pierre.kunzli@hesge.ch
Paul Albuquerque paul.albuquerque@hesge.ch +41 22 546 25 54
Orestis Malaspinas orestis.malaspinas@hesge.ch +41 22 546 24 20
-------------------- ------------------------------ --------------------
Utilisez le libre service (l'horaire sera fixé prochainement).
# Organisation du cours (I/II)
## But: Illustration des concepts vus au cours d'algorithmique
- Salle A502 pour la "théorie" (présentation langage et TPs).
- Salles A432-A433 pour la "pratique".
## Le bâton
- Présence en cours obligatoire (13h-16h45 tous les mercredis).
## La carotte
- Rare cours d'informatique de première.
- Travaux pratiques amusants et stimulants.
# Organisation du cours (II/II)
- Projets à faire en C.
- Les projets doivent compiler sur les machines de l'école $\Rightarrow$ utilisation de Linux obligatoire.
- Chaque projet aura un dépôt git propre sur <https://githepia.hesge.ch/>
- Recommandation: Utilisez uniquement Linux (dual boot ou machine virtuelle sur vos portables).
# Évaluations
## Deux projets notés par semestre
- Chaque projet ($\sim 7$ semaines) est composé de plusieurs parties.
- Chaque sous partie n'est pas notée indépendamment.
- Moralité: Ne vous y mettez pas au dernier moment.
## Les deux projets du semestre
- Librairie de traitement d'images.
- Représentation 3d du canton de Genève à partir de données LIDAR.
my_highlight.theme 0 → 100644
+ 204
− 0
View file @ 8405fb8f
{
"text-color": null,
"background-color": "#f0f0f0",
"line-number-color": "#aaaaaa",
"line-number-background-color": null,
"text-styles": {
"Other": {
"text-color": "#8f5902",
"background-color": null,
"bold": false,
"italic": false,
"underline": false
},
"Attribute": {
"text-color": "#c4a000",
"background-color": null,
"bold": false,
"italic": false,
"underline": false
},
"SpecialString": {
"text-color": "#4e9a06",
"background-color": null,
"bold": false,
"italic": false,
"underline": false
},
"Annotation": {
"text-color": "#8f5902",
"background-color": null,
"bold": true,
"italic": true,
"underline": false
},
"Function": {
"text-color": "#000000",
"background-color": null,
"bold": false,
"italic": false,
"underline": false
},
"String": {
"text-color": "#4e9a06",
"background-color": null,
"bold": false,
"italic": false,
"underline": false
},
"ControlFlow": {
"text-color": "#204a87",
"background-color": null,
"bold": true,
"italic": false,
"underline": false
},
"Operator": {
"text-color": "#ce5c00",
"background-color": null,
"bold": true,
"italic": false,
"underline": false
},
"Error": {
"text-color": "#a40000",
"background-color": null,
"bold": true,
"italic": false,
"underline": false
},
"BaseN": {
"text-color": "#0000cf",
"background-color": null,
"bold": false,
"italic": false,
"underline": false
},
"Alert": {
"text-color": "#ef2929",
"background-color": null,
"bold": false,
"italic": false,
"underline": false
},
"Variable": {
"text-color": "#000000",
"background-color": null,
"bold": false,
"italic": false,
"underline": false
},
"Extension": {
"text-color": null,
"background-color": null,
"bold": false,
"italic": false,
"underline": false
},
"Preprocessor": {
"text-color": "#8f5902",
"background-color": null,
"bold": false,
"italic": true,
"underline": false
},
"Information": {
"text-color": "#8f5902",
"background-color": null,
"bold": true,
"italic": true,
"underline": false
},
"VerbatimString": {
"text-color": "#4e9a06",
"background-color": null,
"bold": false,
"italic": false,
"underline": false
},
"Warning": {
"text-color": "#8f5902",
"background-color": null,
"bold": true,
"italic": true,
"underline": false
},
"Documentation": {
"text-color": "#8f5902",
"background-color": null,
"bold": true,
"italic": true,
"underline": false
},
"Import": {
"text-color": null,
"background-color": null,
"bold": false,
"italic": false,
"underline": false
},
"Char": {
"text-color": "#4e9a06",
"background-color": null,
"bold": false,
"italic": false,
"underline": false
},
"DataType": {
"text-color": "#204a87",
"background-color": null,
"bold": false,
"italic": false,
"underline": false
},
"Float": {
"text-color": "#0000cf",
"background-color": null,
"bold": false,
"italic": false,
"underline": false
},
"Comment": {
"text-color": "#8f5902",
"background-color": null,
"bold": false,
"italic": true,
"underline": false
},
"CommentVar": {
"text-color": "#8f5902",
"background-color": null,
"bold": true,
"italic": true,
"underline": false
},
"Constant": {
"text-color": "#000000",
"background-color": null,
"bold": false,
"italic": false,
"underline": false
},
"SpecialChar": {
"text-color": "#000000",
"background-color": null,
"bold": false,
"italic": false,
"underline": false
},
"DecVal": {
"text-color": "#0000cf",
"background-color": null,
"bold": false,
"italic": false,
"underline": false
},
"Keyword": {
"text-color": "#204a87",
"background-color": null,
"bold": true,
"italic": false,
"underline": false
}
}
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment