Advertisement
OgreVorbis

PureBasic Micro Tutorial

Apr 22nd, 2022
808
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. ;
  2. ; *** BEFORE USING - MAKE A FILE CALLED 'TEXT.TXT' ON THE C DRIVE AND WRITE A FEW RANDOM LINES OF TEXT WITH NOTEPAD ***
  3.  
  4. ; TYPES OF VARIALBES
  5. ; Global means it can be used anywhere - omiting this means it's local
  6. ; the main variable types you will need are .a .s .i ('i' is automatic if not specified)
  7. ; **YOU ALWAYS DEFINE YOUR GLOBAL VARIABLES AT THE TOP TO AVOID CONFUSION**
  8. ; EXAMPLES
  9.  
  10. ; NOTE: We won't use all of these variables in our code below - some are just examples.
  11.  
  12. #THE_FILENAME = "C:\text.txt" ; this is a constant text string - constants are described later
  13. Global TheNumber = 1000 ; this is automatically an integer (for big numbers) by default because there's no '.i' period after it
  14. Global PushedButton.a = #False ; '.a' after means this uses 1 byte (either for true/false or for numbers 0 - 255). it's the smallest unit available
  15. Global TheText.s = "This is some text" ; you use '.s' to denote a text string variable
  16.  
  17. ; AN ARRAY
  18. Global Dim TheTextLines.s(10, 10) ; this defines a 2D matrix (a.k.a. array) 10 by 10 of text strings
  19. ; how to use it
  20. TheTextLines(1, 1) = "thing" ; now position 1 by 1 equals 'thing'. you can also use 0 by 0 if you want. most things start at zero.
  21. Global Dim RealLines.s(0) ; this one is also an array, but with one dimension. it's zero because the size will be defined later - we don't know how much space we need yet
  22.  
  23. ; LOCALS
  24. ; if you write a var without using global in front, it'll automatically be local
  25. TheTest.a = #True
  26. HappyFrank.s = "happy to be"
  27.  
  28. ; EXAMPLES OF PROCEDURES
  29. ; these get called in your code below to use them - like 'LoadSomeText()'. it's used as if it's a built in command in the language.
  30. Procedure LoadSomeText()
  31.     This_Is_A_Variable.a = 50 ; a local variable with a size of 1 byte - can store 0 to 255. it can't be used outside this procedure.
  32.                                                         ; you may use underscore or capitalization in your variable names, just NO SPACES.
  33.     TheText = "this is some new text" ; this one we can access/change in here cause it's Global. we couldn't use HappyFrank in here though (we 'could', but it would be a new var that's cleared.)
  34.     ; put whatever code you want in here
  35. EndProcedure
  36.  
  37. ; these procs don't return anything. if it were to return something, you'd write 'Procedure.i' or 'Procedure.a' for example. SEE BELOW at the next procedure.
  38. Procedure AnotherProc()
  39.     ; more stuff would go in here
  40. EndProcedure
  41.  
  42. ; this proc will count the number of lines in a text file
  43. ; we need to use this below, you'll see
  44. ; FileNumber is a default '.i' that we pass into the procedure like a command parameter.
  45. Procedure.i CountFileLines(FileNumber) ; on a procedure '.i' should be defined if the proc is to return a value. it means this proc will return an integer number, but it could be any of the types.
  46.     Lines = 0 ; automagically an integer cause no '.' after it
  47.     Repeat
  48.         Lines + 1 ; in PB (unlike other langs), we don't say 'Lines = Lines + 1' or 'Lines++' - it's more clear IMO.
  49.         ReadString(FileNumber)
  50.     Until Eof(FileNumber) = #True ; Eof means 'End Of File', so this loop repeats until the end of file has been reached.
  51.     Lines - 1 ; we get one extra blank line at the bottom of the file, so -1 to ignore it
  52.     FileSeek(FileNumber, 0) ; this sets our reading pointer back to the top of the file, so we can later start reading from the begining again.
  53.     ProcedureReturn Lines
  54. EndProcedure
  55.  
  56. ; MACROS
  57. ; macros are simply procs that are basically pasted in place of your code (where ever you write its name)
  58. ; whereas procs actually get referenced and the code jumps into it
  59. ; so if you use a long macro too often, it will bloat your code because it's pasting copies of it everywhere - in that case, use a procedure
  60. ; they are generally used to just make your code look better and more understandable below
  61. Macro BeginingOfFile()
  62.     FileSeek(0, 0)
  63. EndMacro
  64.  
  65. ; ANYTHING OUTSIDE OF/BELOW YOUR PROCS AND VARIABLE DECLARATIONS, IS THE MAIN ENTRY POINT OF YOUR PROGRAM
  66. ; so this is where the program starts executing.
  67. ; For example: This_Is_A_Variable - will not work here because it is local to the procedure called LoadSomeText()
  68.  
  69. If ReadFile(0, #THE_FILENAME) ; opens this text file as file number zero. if you were to open more files, you'd put one, etc. if you are done and CloseFile(0), then you can re-use zero again.
  70.    
  71.     ; we count the number of lines in the file so that we know how big to make the array (1D matrix)
  72.     Lines = CountFileLines(0) ; Lines = the integer returned by using our procedure above
  73.     Dim RealLines.s(Lines) ; this is the array we defined above as 'Global' with a size of zero. we are now re-dimensioning it to the size in the variable 'Lines'
  74.     For CurrentLine = 0 To Lines
  75.         RealLines(CurrentLine) = ReadString(0) ; we read each line from the file and assign it to its proper position in the array
  76.     Next
  77.     BeginingOfFile() ; go back to the begining so we can do it again with a different example. the macro code is pasted here behind the scenes.
  78.    
  79.     #GOODLY_FILE = 0 ; this is an example of a constant. it's denoted with a hashtag. it's a pre-defined variable that can never change at run-time.
  80.                                      ; you could use this constant instead of writing '0' for your file number everywhere. it's just to make your code more readable.
  81.                                         ; Example: OpenFile(#GOODLY_FILE, "B:\text.txt") .... Lines = CountFileLines(#GOODLY_FILE)
  82.     #ANOTHER_FILE = 1   ; if you know your numbers will always be in order... (in some instances you want constants with numbers out of order)
  83.                                         ; you can use an Enumeration and that will automatically number them in order
  84.     Enumeration ; enumerations are convenient because sometimes, you might want to remove an item from the list and not have to change all the following numbers to be in order.
  85.         #FIRST_FILE ; they don't need to be capitalized, but this is the main convention
  86.         #SECOND_FILE
  87.         #THIRD_FILE
  88.     EndEnumeration ; enumerations are very important when dealing with windows and their containing objects (gadgets in PB)...
  89.                                 ; so you don't have to remember the object numbers AND can also insert more objects without changing all the subsequent ones.
  90.    
  91.     ; here is another way to read the lines that's much simpler and doesn't use a procedure like CountFileLines, but it's far slower
  92.     Lines = 0
  93.     Repeat
  94.         RealLines(Lines) = ReadString(#GOODLY_FILE)
  95.         Lines + 1
  96.         ReDim RealLines.s(Lines) ; we are using ReDim here, instead of Dim. ReDim resizes the array and preserves its contents.
  97.                                                          ; so instead of counting the file lines first, we just resize the array once on each loop - slower and junky. to resize and preserve, the system...
  98.                                                          ; has to reallocate a new slightly larger chunk of ram and then copy the contents from the old array into the new larger memory space.
  99.                                                          ; use it sparingly and only when there is absolutely no way to determine the size of something beforehand like we did above.
  100.     Until Eof(#GOODLY_FILE) = #True
  101.     Lines - 1
  102.    
  103.     CloseFile(#GOODLY_FILE)
  104.    
  105.     ; display the lines
  106.     For DisplayLine = 0 To Lines
  107.         MessageRequester(TheText, RealLines(DisplayLine)) ; this shows each line of the array we read in a MessageBox (the term used in mainstream languages).
  108.     Next
  109.    
  110. Else
  111.     MessageRequester(HappyFrank, "The file '" + #THE_FILENAME + "' could not be opened!", #PB_MessageRequester_Error) ; this is the same as MessageBox in VB.
  112. EndIf
Advertisement
RAW Paste Data Copied
Advertisement