Undergrad C

\documentclass[12pt]{report} %Structure \setcounter{tocdepth}{5} \setcounter{secnumdepth}{5} %Structure %Layout \usepackage{geometry} \geometry{ a4paper, total={170mm,257mm}, left=20mm, top=20mm, } \setlength{\footskip}{45pt} %Layout %Text \renewcommand{\familydefault}{\sfdefault} \usepackage{sfmath} \usepackage{parskip} \usepackage{graphicx} %Text %Extra %Extra %Technical Stuff \usepackage{float} \usepackage{amsmath} \everymath{\displaystyle} \DeclareMathOperator{\cosec}{cosec} \DeclareMathOperator{\cosech}{cosech} \DeclareMathOperator{\sech}{sech} \DeclareMathOperator{\arcsec}{arcsec} \DeclareMathOperator{\arccot}{arccot} \DeclareMathOperator{\arccosec}{arccosec} \DeclareMathOperator{\arcsinh}{arcsinh} \DeclareMathOperator{\arccosh}{arccosh} \DeclareMathOperator{\arctanh}{arctanh} \DeclareMathOperator{\arcsech}{arcsech} \DeclareMathOperator{\arccoth}{arccoth} \DeclareMathOperator{\arccosech}{arccosech} \DeclareMathOperator{\Ln}{Ln} \DeclareMathOperator{\sinc}{sinc} %Technical Stuff \begin{document} \tableofcontents \chapter{The C Programmig Languages} \begin{figure}[H] \centering \includegraphics[width=0.3\textwidth]{structure.png} \end{figure} \begin{figure}[H] \centering \includegraphics[width=0.3\textwidth]{memorymap.png} \end{figure} \section{Lexical Conventions} \begin{enumerate} \item ~[Identifiers]\par [is a sequence of underscored letters and digits, reserved are keywords not to be used otherwise] \begin{figure}[H] \centering \includegraphics[width=0.4\textwidth]{keywords.png} \end{figure} \begin{figure}[H] \centering \includegraphics[width=0.6\textwidth]{attributes.png} \end{figure} \begin{figure}[H] \centering \includegraphics[width=0.55\textwidth]{divison.PNG} \end{figure} \item ~[Punctuators] \begin{figure}[H] \centering \includegraphics[width=0.6\textwidth]{operators.png} \end{figure} \item ~[Constants] \begin{enumerate} \item ~[Integers Constants]\par [sequence of digits whose type depends on the prefixes and suffixes [0, 0x, U, L, UL, ULL]] \begin{enumerate} \item ~[Unsuffixed Decimal]: [int, long, unsigned long] \item ~[Unsuffixed Octal, Hexadecimal]: [int, unsigned int, long, unsigned long] \item ~[Suffixed U]: [unsigned int, unsigned long] \item ~[Suffixed L]: [long, unsigned long] \item ~[Suffixed UL]: [unsigned long] \end{enumerate} \item ~[Character Constants]\par [seq of one or sometimes two or more chars enclosed in single quotes ’ ’, of type char] $\text{[’{a, 0, a, b, r f, n,0,ooo, xhh}’]}$ \item ~[Floating Constants]\par [consists of an int, fraction, e or E, signed int exp, type depends on the suffixes [F, L]] \begin{enumerate} \item ~[Unsuffixed]: [double] \item ~[Suffixed F]: [float] \item ~[Suffixed L]: [long double] \end{enumerate} \item ~[String Literals]\par $[\{\text{chars}{\}}^{\ast }][\text{constant array of characters appended with null byte}]$ \end{enumerate} \end{enumerate} \section{Declaration Statements} [a declaration specifies the interpretations given to each identifier]\par [except for statement labels and preprocessor macros, all identifiers are declared by their appearance in C declarations, ordinaries appear in declarators within declarations, and type tags, structure and union components, are declared in certain kind of type specifiers in declarations, while statement labels are declared by their appearance in a C function, and preprocessor macros are declared by the define preprocessor command thus a C file consists of quench of top level declarations, each function has parameter declarations and a body, which in turn may contain various blocks further containing inner declarations, call definition if allocates storage or codes statements] $[\text{storage qualifier1, type qualifier, type specifier1 init-declarator}]$ [constraints]\par [if an identifier has no linkage, there shall be no more than one declaration of the identifier in the same scope and in the same name space, except for incomplete tags]\par [a definition of an identifier is a declaration for that identifier that for an object, causes storage to be reserved for that object, for a function, includes the function body]\par

    [all declarations in the same scope that refer to the same object or function shall specify compatible types]\par
[external definitions]\par
    [no more than one external definition for each identifier, if with internal linkage in a translation unit, if with external linkage in the entire program, moreover if used in an expression, there shall be exactly one external definition for the identifier]\par
 [the identifier declared in a function    definition shall have a function type as specified by the declarator portion of the function definition]\par
    [if the declaration of an identifier for an object has file scope and an initializer, the declaration is an external definition for the identifier while a declaration of an identifier for an object without an initializer and missing extern constitutes a tentative definition such that if a translation unit contains one or more tentatives for an identifier and the translation unit contains no external definition for that identifier, then the behaviour is exactly as if the unit contains the declaration of that identifier with default initializer]

\begin{figure}[H] \centering \includegraphics[width=1\textwidth]{typesp.PNG} \end{figure}

\section{Expressions} [an expression is a syntactic entity in programming language that may be evaluated to its value]\par [lvalue: refers to an object, not necessarily modifiable] [function designator: refers to a function]\par [non modifiables lvalues : array, const qualified, structure or union with const qualified members] \begin{enumerate} \item ~[Pointer Conversion] \begin{enumerate} \item $[\text{’array of T’ : [a pointer to the first object in the array] ’pointer to T’}]$ $[\text{Excp]: [\&, ++, - -, sizeof, :=’s]}$ \item $[\text{’function returning T’ : [pointer to the function itself] ’pointer to function returning T’}]$ $[\text{Excp:}][\&]$ \end{enumerate} \item ~[Primary Expressions] $[\text{identifiers; constants; (expression)}]$ \item Postfix Expressions [LR] \begin{enumerate} \item ~[Array References] $[\text{pointer to T[integral]∼ integral[pointer to T]∼ ∗((E1)+(E2))}]$ \item ~[Function Calls] $[\text{pointer to a function returning T(arguments)}]$ [while in preparing function call, a copy is made of each argument passing strictly by value, such that the arguments are converted as if by assignment to the types of the corresponding parameters of function’s prototype, recursive calls to any function are permitted] \item ~[Structure References]\par $\text{[str, un . mem]∼ [ptr to str, un -> memb]}$ \item ~[Postfix Incrementation] $[\text{arithmeticp ±±}]$ [after the value is noted, the operand is incremented or decremented by 1, as in additions] \end{enumerate} \item Unary Operators \begin{enumerate} \item ~[Prefix Increment Operators] $[\text{±± arithmeticp}]$ \item ~[Address Operator] $[\&\text{non register types}]$ \item ~[Indirection Operator] ${[}^{\ast }\text{non pointer to void types}]$ \item ~[Logical Negation] $[!\text{arithmeticp}]$ \item ~[SizeOf] $[sizeof\text{(any types or spd)}]$ \end{enumerate} \item ~[Casts]: $[\text{(ar)ar; (itr)ptr; (ptrO)itr; pvoid, ptrO; (ptrF)itr, ptrF, (void)any}]$ \item ~[Multiplicative][Additional][Relational, Equality][Logical AND, OR] \item ~[Conditional] $[\text{[ar, ptr] ? [ar; str; ptr] : [ar; str; ptr]}]$ \item ~[Assignment Operators] $[\text{ar = ar; str = str; pvoid = 0, ptrO, pvoid; ptrO = 0, ptrO, pvoid; ptrF = 0, ptrF}]$ $[{\text{E}}_{1}op={\text{E}}_2\sim {\text{E}}_1={\text{E}}_{1}op{\text{E}}_2]$ \item ~[Comma] $[,]$ \section{Control Flow} \begin{enumerate} \item ~[IfElse] $[if\text{ (expression) }\{{\text{statements}}_1;\}else\{{\text{ statements}}_2;\}]$ $[\text{ambigued to the inner}]$ \item ~[IfElseIf] $[if\text{ (expression) }\{\text{statements;}\}elseif\text{ (expression) }\{\text{statements};\}\dots else\{\text{statements};\}]$ \item ~[Switch] $[switch\text{ (expression)}\{case\text{ const-int-exp}:\{\text{statements};\}\dots default:\{\text{statements};\}\}]$ \item ~[Loops] $[while\text{ (expression)}\{\text{statements};\}]$ $[for(\text{int exp, dec};\text{check exp};\text{incr exp})\{\text{statements;}\}]$ $[do\{\text{statements};\}while\text{ (expression)}]$ \item ~[Exits For Switch, Loops] $[break;]:[\text{immediate exit}]$ $[continue;{]}_{\text{not for switch}}:[\text{next iteration}]$ \item ~[Goto Labels] $[\text{label}:\dots goto\text{label};][\text{entire function}]$ \end{enumerate} \section{Preprocessing} \begin{enumerate} \item ~[File Inclusion]: [\#include~"\text{header.h}"~<\text{file.h}>]$$$$[\text{includes the header files into the source code}] \item ~[Macro Substitution] $[\#define\text{name(parameters)}\text{replacement},\#undef\text{name}]$ $[\text{replaces subsq occurrence of token, forgets the macros if defined else harmless}]$ [Operators] $[\text{stringizing}(\#),\text{tokenpasting}(\#\#)]$ \item ~[Conditional Compilation] $[\#if\#elif\#else\#endif,\#ifdef\#endif]$ $[\text{equivalent to elseif’s control flow for compilation}]$

\end{enumerate}

\section{Library Functions} \begin{enumerate} \item ~[File Operations]:\par [a stream is a source or a destination of data, communication medium with a program, that may be associated with a disk or other peripheral which is connected to a file or a device by opening it, while the connection is broken by closing the stream]\par [standard streams linked with io; streams, stdin, stdout, stderr, are pre opened]\par [a program writes to the streams temporarily through the buffer memory associated with the stream]\par $[FILE{}^{\ast }fopen(constchar{}^{\ast }filename,constchar{}^{\ast }mode)]$ $[intfflush(FILE{}^{\ast }stream)]$ $[intfclose(FILE{}^{\ast }stream)]$ \begin{figure}[H] \centering \includegraphics[width=0.6\textwidth]{modechart.png} \end{figure} \item ~[Formatted Output And Input]\par [data is written in computer encoded form, in case of failure functions returns NULL or EOF] $[intfprintf(FILE{}^{\ast }stream,constchar{}^{\ast }format,arg1,\dots )]$ $[\%[widt{h}_r[.precisionwidth][lengthmodifier:c,d,f,s,o,x]]$ $[intfscanf(FILE{}^{\ast }stream,constchar{}^{\ast }format,\&arg1,\dots )]$ $[\%[lengthmodifier:c,d,f,s]]$ $[\#defineprintf(\dots )fprintf(stdout,\dots ),\#definescanf(\dots )fscanf(stdin,\dots )]$ [characters speculation] $[intfgetc(FILE{}^{\ast }stream),intfputc(constintc,FILE{}^{\ast }stream)]$ $[\#definegetchar()fgetc(stdin),\#defineputchar(constintc)fputc(intc,stdout)]$ [strings speculation] $[char{}^{\ast }fgets(char{}^{\ast }str,intn,FILE{}^{\ast }stream),intfputs(constchar{}^{\ast }str,FILE{}^{\ast }stream)]$ [integers or bulk speculations] $[intgetw(FILE{}^{\ast }stream),intputw(constintvalue,FILE{}^{\ast }stream)]$ $[size\_tfread(void{}^{\ast }stream,size\_tsize,size\_tn,FILE{}^{\ast }stream]$ $[size\_tfwrite(constvoid{}^{\ast }stream,size\_tsize,size\_tn,FILE{}^{\ast }stream]$ [random access to the files] $[intfseek(FILE{}^{\ast }stream,longdisplacement,SEEK\_SET|SEEK\_CURRENT|SEEK\_END)$ $[longftell(FILE{}^{\ast }stream]$ [error handling functions] $[intfeof(FILE{}^{\ast }stream),intferror(FILE{}^{\ast }stream]$ [in many environments for redirection of input or output] $[(\text{prog})<(\text{infile}),(\text{prog})>(\text{outfile}),\text{(otherprog)}|\text{(prog)}]$ \item ~[Memory Allocation] \par[manual memory management for dynamic memory allocation in free store] $[void{}^{\ast }malloc(size\_tsize):ptr=(datatype{}^{\ast })malloc(noofdt\ast sizeof(datatype))]$ $[void{}^{\ast }calloc(size\_tn,size\_tsize):ptr=(datatype{}^{\ast })malloc(noofdt,sizeof(datatype))]$ $[void{}^{\ast }realloc(void{}^{\ast }ptr,size\_tnewsize):ptr=(dt{}^{\ast })realloc(ptr,noofdt\ast sizeof(dt))]$ $[voidfree(void{}^{\ast }ptr]$ \item ~[Strings Manipulation]\par [single strings, dealings, checking occurences from pointing head to ending character] $[size\_tstrlen(constchar{}^{\ast }str)]$ $[char{}^{\ast }strrev(char{}^{\ast }str)]$ $[char{}^{\ast }strcat(char{}^{\ast }str1,constchar{}^{\ast }str2)]$ $[char{}^{\ast }strcpy(char{}^{\ast }str1,constchar{}^{\ast }str2)]$ $[char{}^{\ast }[strchr|strrchr](constchar{}^{\ast }str,constintch)]$ $[char{}^{\ast }strstr(constchar{}^{\ast }str1,constchar{}^{\ast }str2)]$ $[char{}^{\ast }strpbrk(constchar{}^{\ast }str1,constchar{}^{\ast }str2)]$ $[intstrcmp(constchar{}^{\ast }str1,constchar{}^{\ast }str2)]$ \item ~[Mathematics]\par [trigonometrics]$[double[sin,cos,tan,asin,acos,atan,sinh,cosh,tanh,asinh,acosh,atanh](doublex)]$ [generals] $[double[exp,log,log10,sqrt,](doublex)]$

\end{enumerate}

\end{enumerate} \end{document}