(Ghidul dezvoltatorului pentru microcontrolerele din familia HCS08)

În Exemplul 12.1, ne vom uita la codul care vă permite să scrieți și să ștergeți datele native din memoria flash. Astfel de acțiuni sunt necesare dacă utilizatorul unui dispozitiv face setări suplimentare pentru acest dispozitiv și dorește ca configurația selectată să fie păstrată după oprirea alimentării.

Anterior, am observat că familia de MCU-uri HCS08 nu permite ștergerea și programarea operațiunilor de memorie flash, executând programul de control al acestor moduri și din memoria flash. Asigurați-vă că mai întâi rescrieți codul programului responsabil de ștergerea și programarea operațiunilor în RAM, apoi rulați acest cod pentru execuție. În timpul procesului de ștergere și programare, modulul de memorie flash va fi tensiune crescută. Cu toate acestea, acest lucru nu va duce la întreruperea programului, deoarece la un moment dat va fi executat din RAM.

NXP a dezvoltat un set de utilitare în limbaj de asamblare care facilitează crearea propriei dvs codul programului pentru programarea memoriei flash sub controlul programului de operare al dispozitivului. Aceste utilitare sunt localizate în fișier doonsstack.asm. Acest fișier ar trebui inclus în proiect, așa cum se arată în Fig. 12.3.

Orez. 12.3. Fereastra de proiect cu fișierul inclus doonsstack.asm.

Conținutul fișierului doonsstack.asm prezentat mai jos. Dat text original a codului de program utilizat, deci comentariile nu pot fi traduse.

;* Această papetărie este menită să servească drept cadru pentru un *
;* aplicație utilizator. Pentru un program mai cuprinzător care *
;* demonstrează funcționalitatea mai avansată a acestui *
;* procesor, vă rugăm să vedeți aplicațiile demonstrative *
;* situat în subdirectorul exemple al *
;* Metrowerks Codewarrior pentru directorul programului HC08 *
;**************************************************************
; simboluri de export
XDEF DoOnStack
XDEF FlashErase
XDEF FlashProg
; folosim export „Entry” ca simbol. Acest lucru ne permite
; referiți „Entry” fie în fișierul linker .prm
; sau din C/C++ mai târziu

; includ macrocomenzi specifice derivate
Includeți „MC9S08GB60.inc”

Două următoarele rânduri ar trebui să fie necomentate și atribuite valorile dorite.

;mPageErase equ $40
;mByteProg equ $20
mFACCERR equ $10
mFPVIOL equ $20
mFCBEF equ 80 USD
; secțiunea variabilă/date
MY_ZEROPAGE: SECȚIUNEA SCURTĂ
; Introduceți aici definiția datelor dvs. Pentru demonstrație, se folosește temp_byte.
; temp_byte ds.b 1
; secțiunea de cod
MyCode: SECȚIUNE
;**************************************************************
; această rutină de asamblare se numește aplicație C/C++
DoOnStack: pshx
pshh; salvează indicatorul pentru a clipi
psha; comanda de salvare pe stivă
ldhx #SpSubEnd ;punctează ultimul octet pentru a se muta în stivă;
SpMoveLoop: lda ,x ;citește din flash
psha ;mutare pe stivă
aix #-1 ;următorul octet de mutat
cphx #SpSub-1 ;sfârșit trecut?
bne SpMoveLoop; buclă până la întregul sub pe stivă
tsx ;punctează către sub pe stivă
tpa ;mută CCR în A pentru testare
și #$08 ;verificați masca I
bne I_set ;sări peste dacă am setat deja
sei ;block se întrerupe în timp ce FLASH este ocupat
lda SpSubSize+6,sp ;preîncărcare date pentru comandă
cli ;ok pentru a șterge masca acum
bra I_cont ;continuați să stivuiți de-alocarea
I_set: lda SpSubSize+6,sp ;preîncărcare date pentru comandă
jsr ,x ;execută sub-ul pe stivă
I_cont: ais #SpSubSize+3 ;dealocare subcorp + H:X + comandă
Indicatorul flash ;H:X OK de la SpSub
lsla ;A=00 & Z=1 cu excepția cazului în care PVIOL sau ACCERR
rts ;pentru a clipi unde a fost apelat DoOnStack
;**************************************************************
SpSub: ldhx LOW (SpSubSize+4), sp; obțineți adresa flash din stivă
sta 0,x ;scrie pe flash; latch adresă și date
lda SpSubSize+3,sp ;obține comanda flash
sta FCMD ;scrie comanda flash
lda #mFCBEF ;mască pentru a iniția comanda
sta FSTAT ; comanda de înregistrare
nu ;[p] vreau min 4~ de la ciclul w la r
ChkDone: lda FSTAT ; deci FCCF este valabil
lsla ;FCCF acum în MSB
bpl ChkDone ;buclă dacă FCCF = 0
SpSubEnd: rts ;înapoi în DoOnStack în flash
SpSubSize: equ (*-SpSub)
;**************************************************************
FlashErase: psha; ajusta sp pentru intrarea DoOnStack

lda #mPageErase ;model de mască pentru comanda de ștergere a paginii
bsr DoOnStack ;comandă de finalizare de la sub baza de stivă
rts
;**************************************************************
FlashProg: psha ;salvați temporar datele de intrare
lda #(mFPVIOL+mFACCERR) ;mască
sta FSTAT; anulează orice comandă și șterge erorile
lda #mByteProg ;model de mască pentru comanda byte prog
bsr DoOnStack ;execută codul de prog din stiva RAM
ais #1 ;dealocarea locației datelor din stivă
rts
;**************************************************************

Tot în textul codului programului în C este necesar să existe o directivă #include fișier de conectare doonsstack.h, al cărui text este prezentat mai jos.

/* */
/* Numele proiectului: doonstack.h */
/* Ultima modificare: 04/11/2004 */
/* De către: r60817 */
/* */
/* */
/**********************************************************************/
/* */
/* Descriere: MC9S08GB60_FLASH_DOONSTACK - demo */
/* */
/* */
/* Documentație: MC9S08GB60/D Rev. 2,2 */
/* HCS08RMv1/D Rev. 1(4.8Exemple de aplicații FLASH) */
/* */
/* Acest software este clasificat ca Software Sample de inginerie. */
/* */
/**********************************************************************/
/* */
/* Serviciile efectuate de FREESCALE în această chestiune sunt efectuate CA ESTE */
/* și fără nicio garanție. CLIENTUL își păstrează decizia finală */
/* raportat la designul și funcționalitatea totală a produsului final. */
/* FREESCALE nici nu garantează și nici nu va fi tras la răspundere de către CLIENT */
/* pentru succesul acestui proiect. FREESCALE RENUNȚĂ TOATE */
/* GARANȚII, EXPRESE, IMPLICITE SAU STATUTARE INCLUSIV, DAR NU */
/* LIMITAT LA GARANȚIA IMPLICITĂ A VANZĂBILITĂȚII SAU ADEVĂRII PENTRU O */
/* SCOP PARTICULAR PRIVIND ORICE CONSULTARE HARDWARE, MINERU SOFTWARE FURNIZAT */
/* LA PROIECTUL PE FREESCALE SAU NU PRODUSUL REZULTAT DIN */
/* SERVICII FREESCALE . ÎN NICIO CAZ FREESCALE NU VA FI RESPONSABIL PENTRU */
/* DAUNE INCIDENTALE SAU CONSECUȚIONALE DERIVATE DIN ACEST ACORD. */
/* */
/* CLIENTUL este de acord să țină FREESCALE inofensiv împotriva oricăror */
/* revendică cereri sau acțiuni ale oricui din cauza oricărei daune sau */
/* vătămare, fie comercială, contractuală sau sinuoasă, în creștere */
/* direct sau indirect ca urmare a sfaturilor sau asistenței */
/* a furnizat CLIENTUL în legătură cu produse, servicii sau bunuri */
/* furnizat în temeiul prezentului acord. */
/* */
/**********************************************************************/
/*
- acest fișier API între main.c și doonstack.asm
*/
#ifndef _doonsstack
#define_doonstack
#ifdef __cplusplus
extern "C" ( /* funcțiile noastre de asamblare au convenția de apelare C */
#endif
void DoOnStack(void); /* prototip pentru rutina DoOnStack */
void FlashErase(unsigned char *); /* prototip pentru rutina FlashErase */
/* Comanda de ștergere a paginii */
void FlashProg(unsigned char *, unsigned char); /* prototip pentru rutina FlashProg */
/* Comanda programului octet */
#ifdef __cplusplus
}
#endif

#endif /* _doonsstack */
/**********************************************************************/

În exemplul nostru, un bloc de 512 octeți este rezervat pentru înregistrarea datelor nevolatile. Această dimensiune a blocului a fost aleasă deoarece este cantitatea minimă de celule de memorie flash permisă pentru ștergere în microcontrolerul MC9S08QG8. Blocul selectat va fi localizat la începutul spațiului de adrese al memoriei flash rezidente a MK: de la 0xE000 la 0xE1FF. Codul programului va începe la adresa 0xE200 și poate ocupa spațiu de adresă până la 0xFFFF.

Pentru a implementa plasarea intenționată a datelor și a codurilor de program, ar trebui să modificați setările linkerului din fișier proiect.prm.

În proiectul standard a existat o intrare:

ROM = READ_ONLY 0xE000 TO 0xFFAD;

Ar trebui inlocuit:

SEGMENTE /* Aici sunt listate toate zonele RAM/ROM ale dispozitivului */
ROM = READ_ONLY 0xE200 TO 0xFFAD;

În exemplul nostru, se folosește și modul de protecție la scriere al zonei de cod de program, adică. spațiu de adrese de la 0xF200 la 0xFFFF. În fig. Figura 12.4 prezintă procesul de generare a codului pentru registrul FPROT, care protejează spațiul de adrese 0xF200...0xFFFF de ștergerea/scrierea accidentală. Cei mai semnificativi șapte biți ai ultimei adrese 0xF1FF a spațiului de adrese neprotejat trebuie să fie scriși în registrul FPROT.

Abordare	A15	A14	A13	A12	A11	A10	A9	A8	A7	A6	A5	A4	A3	A2	A1	A0
0xE1FF	1	1	1	0	0	0	0	1	1	1	1	1	1	1	1	1
	⇓
FPOT	FPS7	FPS6	FPS5	FPS4	FPS3	FPS2	FPS1	FPDIS
0xE0	1	1	1	0	0	0	0	0

Orez. 12.4. Formarea unei înregistrări de cod de securitate pentru registrul FPROT.

Exemplul 12.1. Operații cu date nevolatile în memoria flash

// Placă demonstrativă DEMO9S08QG8
// șterge/scrie/citește memoria flash rezidentă
#include /* pentru macrocomanda EnableInterrupts */
#include "derivative.h" /* include declarații periferice */
#include "hcs08.h" /* Acesta este fișierul nostru de declarație! */
#include „doonstack.h”
#define BUSCLK 8000000
#define vFCDIV (BUSCLK/200000-1)
char fdata, operare;
unsigned int faddress;
// Atribuiți o zonă de adrese protejată la scriere: de la 0xE200 la 0xFFFF
const byte NVPROT_INIT @0x0000FFBD = 0xE0;
// Inițializarea MK
void mcu_init(void)
{
SOPT1 = bBKGDPE; // Activați funcția de linie de depanare BKGD
ICSSC = NV_FTRIM; // Scrieți valoarea de tăiere FTRIM
ICSTRM = NV_ICSTRM; // Scrieți valoarea TRIM trim
ICSC2 = 0; // ICSOUT = DCOOUT / 1
// BUSCLK = 8 MHz
FCDIV = vFCDIV; // Scrieți valoarea codului divizor pentru frecvența FCLK
// (FCLK = 200 kHz)
}
#pragma inline
// Funcție pentru citirea unui octet dintr-o celulă de memorie cu o adresă dată
char flash_read (adresă int nesemnată)
{
unsigned char *pointer;
pointer = (car*) adresa;
return (*pointer);
}
// Funcție pentru scrierea unui octet într-o celulă de memorie cu o adresă dată
char flash_write (adresă int nesemnată, date char nesemnate)
{
unsigned char *pointer;
pointer = (car*) adresa;
FlashProg(pointer,date); // Apelați funcția de programare flash
dacă (FSTAT_FACCERR) date=1; else data=0;
if (FSTAT_FPVIOL) date|=2;
returnare(date);
}
// Funcție pentru ștergerea unui bloc specificat în zona de memorie flash
unsigned char flash_sector_erase (adresă int nesemnată)
{
unsigned char *pointer, res;
pointer = (car*) adresa;
FlashErase(pointer);
dacă (FSTAT_FACCER) res=1; else res=0;
if (FSTAT_FPVIOL) res|=2;
returnare(res);
}
void main(void)
{
mcu_init();
fdata = 0;
faddress = 0xE000;
operare = 0;
în timp ce (1)
{
comutator (operare)
{
cazul 1: // Șterge bloc
fdata = flash_sector_erase(faddress);
operare = 0;
pauză;
cazul 2: // Scrie un octet
fdata = flash_write(faddress,fdata);
operare = 0;
pauză;
cazul 3: // Citiți octetul
fdata = flash_read(faddress);
operare = 0;
pauză;
}
}
}

Să luăm în considerare metodologia de testare a codului de program din Exemplul 12.1. Pentru a face acest lucru, în fereastra de depanare Date hai sa adaugam trei variabile: faddress, fdata, Operațiune. De asemenea, vom seta fereastra în modul de actualizare periodică, de exemplu, la fiecare 200 ms.

Înainte de a rula codul programului, scrieți-l într-o variabilă faddress adresa pentru scriere și într-o variabilă fdata— octetul de date de scris. Lângă variabilă Operațiune notează codul 0x02. După rularea codului exemplu, va începe să scrie un octet de date în celula de memorie flash selectată. Vă rugăm să rețineți că celula selectată trebuie să fie într-o stare ștearsă, de ex. ar trebui să conțină codul 0xFF.

Pentru a șterge blocul de memorie 0xE00...0xE1FF, scrieți la faddress orice adresă din intervalul specificat și setați variabila Operațiuneîn 1. Apoi, rulați din nou codul pentru execuție.

Citirea datelor din memoria flash este, de asemenea, ușoară. Pentru a face acest lucru, scrieți în variabilă faddress codul adresei, într-o variabilă Operațiune- cod 0x03. Conținutul celulei de memorie flash selectată va fi afișat în variabilă fdata după executarea codului programului.

Vă rugăm să rețineți că funcțiile flash_write()Și flash_sector_erase() returnează o variabilă de tip muncă de sezon cu un cod de eroare la efectuarea acțiunii: 0 - nu a fost nicio eroare, 0x02 - a existat o eroare de acces, 0x04 - a existat o încercare de ștergere/scriere a spațiului de adrese protejat. Ambele funcții menționate mai sus necesită aproximativ 35 de octeți de memorie stivă pentru a fi executate. Dacă suprafața reală a stivei este mai mică, va apărea o eroare fatală. Va fi posibilă restabilirea funcționalității programului numai prin resetarea MK.

Pentru a vedea modificările flash în depanator, trebuie să faceți unele modificări la configurația debugger. Urmând setările implicite, depanatorul citește zona de memorie flash MCU o singură dată după începerea unei sesiuni de depanare. Pentru a modifica configurația, selectați opțiunea din meniul principal de depanare MultilinkCyclonPro > Depanare hartă memorie. Se va deschide fereastra prezentată în fig. 12.5, a. Selectați în această fereastră bloc de memorie 3și apăsați butonul Modificare/Detalii. În noua fereastră prezentată în Fig. 12.5, b, selectați opțiunea marcată. Acest lucru va permite depanatorului să actualizeze periodic fereastra de memorie.

Orez. 12.5. Modificați configurația depanatorului pentru a actualiza periodic conținutul ferestrei de memorie.

În fiecare zi apar tot mai multe aplicații pentru Android. Milioane de jocuri interesante și programe utile pot fi găsite în Play Market. Toate au interfață ușor de utilizatși face față sarcinii. Este greu de imaginat lumea modernă fără ele tehnologia Informatiei. Acest articol se adresează persoanelor care nu numai că prețuiesc funcționalitatea și aspect aplicații și sunt, de asemenea, interesați de structura lor internă.

Dacă te-ai întrebat vreodată ce este „sub capota” aplicației tale preferate și știi puțin despre programare, acest articol este pentru tine. Vă vom spune cum să vizionați sursă Aplicații Android direct pe gadgetul dvs. Merge!

Informații generale

Majoritatea programelor pentru sistemul de operare Android, precum și majoritatea sistem de operare, scris într-un limbaj de programare. Aceasta înseamnă că, dacă ne uităm la codul sursă al programelor Android, cel mai probabil vom vedea codul Java folosind Android SDK(care include instrumente pentru platforma Android). Repet: pentru a înțelege codul sursă al aplicațiilor, trebuie să aveți cunoștințe de bază despre Java și principiile Android.

Cum să aflați codul sursă al aplicațiilor Android?

Mai întâi, descărcați aplicația al cărei cod sursă vă interesează. Apoi accesați Play Market și descărcați un utilitar numit Show Java. Ea va fi cea care va face decompilarea. Instalat? Grozav, acum să trecem la partea distractivă - extragerea originalului Cod Android programe. Lansați Show Java.

Selectați aplicația potrivită din cele instalate, sau găsiți-l pe cardul SD. Acum trebuie să selectați un decompilator. De obicei aleg CRF. Dacă aveți probleme, încercați JaDX.

La finalizarea procesului, veți primi o listă de pachete cu sursele aplicației Android. Desigur, aceasta nu este o copie 100% a codului pe care l-au scris dezvoltatorii acestei aplicații. Dar logica de bază rămâne aceeași și nu este greu de înțeles. Ce să faci cu sursele? Orice. Uite, aruncă o privire, poate că vei fi interesat de unele „funcții” sau caracteristici ale implementării funcționalității programului.

Titlu:

Scop

Codul sursă este fie folosit pentru a produce cod obiect, fie executat de un interpret. Modificările nu se fac niciodată codului obiect, ci doar codului sursă și apoi sunt convertite înapoi în cod obiect.

Un alt scop important al codului sursă este descrierea unui program. Pe baza textului programului, puteți reconstrui logica comportamentului acestuia. Comentariile sunt folosite pentru a face codul sursă mai ușor de înțeles. Există, de asemenea unelte, permițându-vă să primiți automat documentația cu privire la codul sursă - așa-numitul. generatoare de documentație.

În plus, codul sursă are multe alte utilizări. Poate fi folosit ca instrument de predare; Programatorii începători pot considera că este util să examineze codul sursă existent pentru a învăța tehnicile și metodologia de programare. De asemenea, este folosit ca instrument de comunicare între programatori experimentați datorită naturii sale concise și lipsite de ambiguitate. Partajarea codului între dezvoltatori este adesea citată ca un factor care contribuie la îmbunătățirea experienței programatorului.

Programatorii mută adesea codul sursă (în module, ca atare sau cu adaptări) de la un proiect la altul, ceea ce se numește reutilizare a codului.

Sursă - componenta esentiala pentru procesul de portare a software-ului pe alte platforme. Fără codul sursă al oricărei piese de software, portarea este fie prea dificilă, fie complet imposibilă.

Organizare

Codul sursă al unei părți a software-ului (modul, componentă) poate consta din unul sau mai multe fișiere. Codul programului nu este neapărat scris într-un singur limbaj de programare. De exemplu, adesea programele scrise în limbaj C, în scopuri de optimizare, conțin inserții de cod în limbaj de asamblare. De asemenea, este posibil ca unele componente sau părți ale unui program să fie scrise în limbi diferite și apoi asamblate într-un singur modul executabil folosind o tehnică cunoscută sub numele de linking library ( legarea bibliotecii).

Software-ul complex necesită zeci sau chiar sute de fișiere de cod sursă pentru a fi construite. În astfel de cazuri, pentru a simplifica construirea, sunt utilizate de obicei fișiere de proiect care conțin o descriere a dependențelor dintre fișierele de cod sursă și descriu procesul de construire. Aceste fișiere pot conține, de asemenea, opțiuni pentru compilator și mediul de proiectare. Poate fi folosit pentru diferite medii de design fișiere diferite proiect, iar în unele medii aceste fișiere pot fi în format text, potrivit pentru editare directă de către programator folosind universal editori de text, în alte medii sunt acceptate formate speciale, iar fișierele sunt create și modificate folosind programe de instrumente speciale. Fișierele de proiect sunt de obicei incluse în termenul „cod sursă”. Marea majoritate a mediilor de limbaj moderne necesită utilizarea fișierelor de proiect, indiferent de complexitatea celuilalt cod sursă inclus în acest proiect. Adesea, codul sursă se referă și la fișierele de resurse care conțin diverse date, de exemplu, imagini grafice necesare pentru a construi un program.

Pentru a facilita lucrul cu codul sursă, pentru colaborarea la cod de către o echipă de programatori, se folosesc sisteme de control al versiunilor.

Calitate

Spre deosebire de oameni, nu există un cod „bine scris” sau „prost scris” pentru un computer. Dar modul în care este scris codul poate influența foarte mult procesul de întreținere a software-ului. Calitatea codului sursă poate fi apreciată după următorii parametri:

• lizibilitatea codului (inclusiv prezența comentariilor la cod);
• ușurință de suport, testare, depanare și corectare a erorilor, modificare și portare;
• utilizarea economică a resurselor - memorie, procesor, spațiu pe disc;
• absența comentariilor emise de compilator;
• absența „gunoaielor” - variabile neutilizate, blocuri de cod inaccesibile, comentarii învechite inutile etc.;
• tratarea adecvată a erorilor;
• portabilitate - abilitatea de a utiliza un handler (compilator, interpret, traducător) versiuni diferite, sau chiar un sistem de operare diferit;
• posibilitatea de internaționalizare a interfeței.

Cod sursă neexecutabil

Licențele copyleft pentru software gratuit necesită distribuirea codului sursă. Aceste licențe sunt adesea folosite și pentru lucrări care nu sunt software - de exemplu, documentație, imagini, fișiere de date pentru jocuri pe calculator.

În astfel de cazuri, codul sursă este considerat a fi forma lucrării care este preferată pentru editare. În alte licențe decât software, aceasta poate fi denumită și versiunea „format transparent”. Acesta ar putea fi, de exemplu:

• pentru un fișier comprimat cu pierdere de date - versiunea fără pierderi;
• pentru redarea unei imagini vectoriale sau a unui model tridimensional - respectiv, versiunea vectorială și modelul;
• pentru o imagine text - același text în format text;
• pentru muzică - un fișier în formatul intern al editorului muzical;
• și în final, fișierul în sine, dacă îndeplinește condițiile specificate, sau dacă mai mult versiune convenabilă pur și simplu nu a existat.

Vezi si

Fundația Wikimedia. 2010.

Vedeți ce este „Codul sursă” în alte dicționare:

Materiale sursă ale filmului: negativ, contratipărire, copie de control a filmului, fonograme magnetice originale de dublare muzicală, zgomot, master video fonogramă, CD etc. Sinonime: textul este fie executat direct de interpret, fie... ... Dicţionar financiar

Un text scris de om al unui program de calculator în orice limbaj de programare. Akademik.ru. 2001... Dicţionar de termeni de afaceri

sursă- - Subiecte telecomunicații, concepte de bază Cod sursă EN... Ghidul tehnic al traducătorului

sursă- 3.1.13 cod sursă: un program de calculator exprimat într-o formă care poate fi citită de om (limbaj de programare) care este tradus în formă care poate fi citită de mașină (codul obiect) înainte de a putea fi testat cu... ... Dicționar-carte de referință de termeni ai documentației normative și tehnice

sursă- limba textului sursă... Dicționar de traducere explicativă

Cod sursă: Codul sursă este textul scris de om al unui program de calculator. Tehno-thriller cu cod sursă regizat de Duncan Jones ... Wikipedia

Acest termen are alte semnificații, vezi codul sursă. Cod sursă Cod sursă ... Wikipedia

Acest articol nu are link-uri către surse de informații. Informațiile trebuie să fie verificabile, altfel pot fi puse sub semnul întrebării și șterse. Poți... Wikipedia

Logo-ul Open Source Initiative (OSI) Software-ul cu sursă deschisă este un software cu sursă deschisă. Codul sursă al programelor create este deschis, adică disponibil pentru vizualizare și modificare. Aceasta este... ... Wikipedia

Program sursă (cod sursă)- 48) program sursă (cod sursă) o reprezentare corespunzătoare a unuia sau mai multor procese care pot fi convertite de un sistem de programare într-o formă executabilă de hardware (cod obiect sau limbaj obiect) (categorii 6, 7 și 9); ... Terminologie oficială

Sursă(de obicei doar textul programului, Engleză cod sursa) - orice set de instrucțiuni sau declarații scrise în limbajul calculatorului programare și într-o formă care poate fi citită de oameni. Codul sursă permite programatorului să comunice cu computerul folosind un set limitat de instrucțiuni.

Cod sursă scris în HTML folosind JavaScript

Codul sursă care reprezintă un program este de obicei conținut în unul sau mai multe fișiere text, uneori stocate în baze de date ca proceduri stocate și poate apărea, de asemenea, ca fragmente de cod tipărite în cărți sau alte suporturi de imprimare. O colecție mare de fișiere de cod sursă poate fi organizată într-un arbore de directoare, caz în care poate fi cunoscut și ca arborele codului sursă(Engleză) arborele sursă) sau arborele de cod arbore de cod sursă etc.

Codul sursă al programului este un set de fișiere necesare pentru a converti dintr-o formă care poate fi citită de om într-o formă de cod executabil de computer. Există două direcții posibile pentru execuția codului: tradus în Codul mașinii folosind un compilator conceput pentru un anumit arhitectura calculatorului, sau realizat direct pe text folosind un interpret.

Goluri

Codul sursă este folosit în principal ca intrare în procesul care produce programe executabile(adică este compilat sau interpretat). De asemenea, este folosit ca mijloc de transfer de algoritmi între oameni (de exemplu, fragmente de cod în cărți). Portarea programului către alții platforme informatice fără cod brut este de obicei destul de complex. Deși opțiunile de portare fără coduri sursă sunt posibile, de exemplu, traducerea binară sau emularea platformei originale.

Licențiere

Instrumentele software și codul sursă care le însoțesc, se încadrează de obicei în una dintre cele două paradigme de licențiere: software cu sursă deschisă și software neliber (sau proprietar). În general, software-ul este deschis, dacă codul sursă poate fi folosit, distribuit, modificat și analizat în mod liber și proprietate, dacă codul sursă este păstrat secret sau este proprietate privată și accesul la acesta este limitat. Pentru a asigura secretul, sunt folosite în primul rând prevederile diferitelor legi privind drepturile de autor, dar sunt adesea folosite și secretele comerciale și brevetele. În plus, distribuția programului vine de obicei cu un acord de licență (EULA), care interzice în primul rând decompilarea, ingineria inversă, analiza, editarea sau eludarea protecției la copiere. Tipuri de protecție a codului sursă (în plus față de compilarea tradițională în codul obiect includ criptarea codului, ofuscarea codului). ofuscarea codului) sau transformarea codului.

Calitate

Modul în care este scris un program poate avea consecințe foarte importante pentru întreținerea lui. Multe manuale de stil de programare insistă asupra importanței lizibilității și multe linii directoare se concentrează pe menținerea codului sursă al unui program, care include depanarea și actualizările. Alte priorități, cum ar fi viteza de execuție a programului și capacitatea de a compila un program pentru mai multe arhitecturi, fac adesea codul mai puțin lizibil factor important, deoarece calitate Codul depinde în întregime de scopul său.

Deoarece programarea a existat la scară industrială de zeci de ani, au fost dezvoltate standarde adecvate de formatare a codului. Unele standarde sunt formalizate, în timp ce altele sunt reguli nerostite. De exemplu, notația maghiară reglementează denumirea identificatorilor într-un program (adesea acest lucru este decis prin emiterea unei convenții de denumire la nivel de întreprindere), alte standarde definesc regulile de aranjare a elementelor de sintaxă.

Acum că înțelegeți conceptul de programare, ne vom uita la codul sursă - componentele sale principale și cum să lucrați cu ele.

Acest articol face parte dintr-o serie de articole despre dezvoltare pentru începători.

Partea 2 – Cod sursă

Multe limbaje de programare vin cu multe biblioteci. De obicei sunt numiti SDK(kituri de dezvoltare software). Încărcat împreună cu compilatorul pentru crearea ulterioară de tehnologii, aplicații și proiecte. Există, de asemenea cadre, creat pentru a facilita dezvoltarea unui proiect și a combina diferitele sale componente.

Unii identificatori incluși în limba selectată nu pot fi utilizați ca identificator de utilizator. Un exemplu este cuvântul şirîn Java. Se apelează astfel de identificatori împreună cu cuvintele cheie Cuvinte rezervate. De asemenea, sunt speciali.

Toate Cuvinte cheie sunt rezervate. De asemenea, cuvintele pe care le alegeți ar trebui să aibă sens pentru cei care le văd pentru prima dată.

Tipuri de date de bază

Codul sursă este o concentrare de diferite tipuri de date: numere(3, 5,7, -100, 3,142) și simboluri(M, A). Unele limbaje de programare descompun numerele în subtipuri, cum ar fi numere întregi(numere întregi).

Numerele întregi pot fi simbolicȘi nesemnat, mare si mic. Acestea din urmă depind de fapt de cantitatea de memorie rezervată pentru astfel de numere. Există numere cu părți zecimale, numite de obicei dublaȘi pluti, în funcție de limba pe care o înveți.

Există, de asemenea tipuri booleene date boolean asta conteaza Adevărat sau fals.

Tipuri complexe de date

Tipurile de mai sus sunt cunoscute ca elementare, primare sau de bază. Putem crea tipuri de date mai complexe din aceste de bază.

matrice( Matrice) este cea mai simplă formă de tip complex. Linia ( Şir) este o matrice de caractere. Nu ne putem lipsi de aceste date și le folosim adesea atunci când scriem cod.

Combinația de caractere este linia. Pentru a folosi o analogie, un șir pentru un computer înseamnă că cuvântul aparține unui om. Cuvântul „termometru” este format din 9 caractere - pur și simplu îl numim șir de caractere. Procesarea șirurilor este un subiect vast pe care ar trebui să-l învețe orice programator aspirant.

Tipurile complexe de date vin cu majoritatea limbajelor de programare care sunt utilizate. Există și altele, cum ar fi sistemele de clasă. Acest fenomen este cunoscut și sub numele de programare orientată pe obiecte ( OOP).

Variabile

Variabilele sunt pur și simplu nume de locații de memorie. Uneori trebuie să stocați datele în codul sursă într-un loc unde le puteți apela pentru a le utiliza. Aceasta este de obicei o locație de memorie care este rezervată de compilator/interpret. Trebuie să denumim aceste celule de memorie pentru a le putea aminti mai târziu. Luați în considerare fragmentul de cod Python de mai jos:

pet_name = "Hippo" tipăriți animal_name

pet_name = "Hipopotami" tipăriți numele_animalului de companie

numele animalului de companie– un exemplu de variabilă și tipul de date stocate în numele animalului de companie, este un șir, ceea ce face ca variabila un șir. Există și numere. Astfel, variabilele sunt clasificate după tipul de date.

constante

Constantele sunt valori care nu se modifică pe parcursul ciclului de viață al unui program. Cel mai des folosite în numele lor litere mari. Unele limbi acceptă crearea de valori persistente, iar altele nu.

Exista limbaje de programare puternic tipizate, în care trebuie să fie fiecare variabilă anumit tip. Odată ce selectați un tip, nu îl veți mai putea schimba. Java bun exemplu o astfel de limbă japoneză.

Alții nu oferă aceste funcții. Sunt scris vag sau limbaje de programare dinamice. Exemplu - Python.

Iată cum să declarați o valoare constantă în JavaScript:

JavaScript

const petName = „Hipopotam”

const petName = „Hipopotam”

Literale

În fiecare cod sursă, există tipuri de date care sunt utilizate pe tot parcursul și se modifică numai dacă sunt editate. Acest literali, care nu trebuie confundat cu variabile sau constante. Niciun cod sursă nu se poate descurca fără ele. Literale pot fi șiruri, numere, zecimale sau orice alt tip de date.

În fragmentul de mai sus, cuvântul „Hippo” este un șir literal. Acesta va fi întotdeauna „Hippo” până când editați codul sursă. Odată ce învățați să codificați, veți învăța cum să manipulați literalele într-un mod care să lase majoritatea codului neschimbat.

Punctuația/Simboluri

În majoritatea programelor scrise veți găsi diverse semne punctuația în funcție de limbajul de programare selectat. De exemplu, Java folosește mai multe semne de punctuație decât Python.

Caracterele de bază includ virgula ( , ), punct și virgulă ( ; ), colon ( : ), bretele ({} ), paranteze regulate ( () ), paranteze drepte (), ghilimele ( «» sau » ), bară verticală ( | ), bară oblică ( \ ), punct ( . ), semnul întrebării ( ? ), vagoane ( ^ ) și procent ( % ).

Bun venit în lumea programării, unde semnele de punctuație sunt cei mai buni prieteni ai tăi. În curând vei descoperi că există întotdeauna o mulțime de ele în codul tău.

Operatori

Șansele ca să scrieți cod sursă pentru a efectua o operațiune sunt extrem de mari. Orice limbaj de programare pe care le folosim include o mulțime de operatori. Printre cele utilizate se numără adăugarea ( + ), Divizia ( / ) înmulțire ( * ), scădere ( — ) și mai mare decât semnul ( > ).

Operatorii sunt de obicei clasificați după cum urmează:

1. Operatori de atribuire. Ele sunt uneori interpretate ca egală, Ce s-a întâmplat. Egalitatea este folosită pentru a compara două valori. Dar operatorul de atribuire atribuie o valoare unei variabile, de exemplu pet_name = „Hippopotam”
2. Operatori aritmetici. Constă din operatori pentru a efectua sarcini aritmetice, cum ar fi adunarea și scăderea. Unele limbaje de programare oferă operatori aritmetici, când alții poate să nu le aibă în arsenalul lor. De exemplu, operatorul modul/restul ( % ) returnează restul operațiunilor de diviziune.
3. Operatori Relaționali. Folosit pentru a compara valori. Acestea includ mai mare decât, mai mic decât, egal cu, nu egal cu. Prezentarea lor depinde și de limbajul de programare pe care îl învățați. Pentru unii PL nu este egal - este <> , pentru ceilalti - != sau !== .
4. Operatori logici. Folosit pentru a efectua operații logice. Operatorii logici folosiți în mod obișnuit sunt Și, sau, Nu. Unele limbi reprezintă acești operatori ca caractere speciale. De exemplu, && a reprezenta logic Și, || - Pentru sau, Și ! - Pentru Nu. Se obișnuiește să se evalueze valorile logice folosind valori booleene Adevărat sau fals.

Comentarii

Documentarea va fi un aspect important al activităților de programare. Acesta este modul în care explicați codul altor programatori. Acest lucru se face folosind comentarii care sunt adăugate la diferite părți ale codului. Cu comentarii, puteți ghida alți programatori prin programul dvs. scris.

Compilatorul ignoră liniile de cod care sunt comentarii.

Declarația de comentarii este diferită pentru limbi diferite. De exemplu, # folosit pentru a introduce comentarii în Python.

Iată un exemplu de comentariu în Python:

# fragment de program pentru calcularea Fibonacci din N numere

Java

// implementare recursivă Import factorial java.util.Scanner; clasa RecursiveFactorial ( public static void main(String args) ( Scanner input=new Scanner(System.in); System.out.print("Găsiți factorul de: "); int num=input.nextInt(); System.out .println("Factorial de "+num+" = "+fact(num) ) static long fact(int n) ( if(n)< 2) return 1; return n * fact(n-1); } }